ID
int64 0
2.65k
| Language
stringclasses 1
value | Repository Name
stringclasses 21
values | File Name
stringlengths 2
48
| File Path in Repository
stringlengths 10
111
⌀ | File Path for Unit Test
stringlengths 16
116
⌀ | Code
stringlengths 66
1.91M
| Unit Test - (Ground Truth)
stringlengths 40
32.1k
⌀ |
|---|---|---|---|---|---|---|---|
2,600 | cpp | google/tsl | strcat | tsl/platform/strcat.cc | tsl/platform/strcat_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_STRCAT_H_
#define TENSORFLOW_TSL_PLATFORM_STRCAT_H_
#include <string>
#include "tsl/platform/macros.h"
#include "tsl/platform/numbers.h"
#include "tsl/platform/stringpiece.h"
#include "tsl/platform/types.h"
namespace tsl {
namespace strings {
enum PadSpec {
kNoPad = 1,
kZeroPad2,
kZeroPad3,
kZeroPad4,
kZeroPad5,
kZeroPad6,
kZeroPad7,
kZeroPad8,
kZeroPad9,
kZeroPad10,
kZeroPad11,
kZeroPad12,
kZeroPad13,
kZeroPad14,
kZeroPad15,
kZeroPad16
};
struct Hex {
uint64 value;
enum PadSpec spec;
template <class Int>
explicit Hex(Int v, PadSpec s = kNoPad) : spec(s) {
static_assert(
sizeof(v) == 1 || sizeof(v) == 2 || sizeof(v) == 4 || sizeof(v) == 8,
"Unknown integer type");
value = sizeof(v) == 1 ? static_cast<uint8>(v)
: sizeof(v) == 2 ? static_cast<uint16>(v)
: sizeof(v) == 4 ? static_cast<uint32>(v)
: static_cast<uint64>(v);
}
};
class AlphaNum {
public:
AlphaNum(int i32)
: piece_(digits_, FastInt32ToBufferLeft(i32, digits_)) {}
AlphaNum(unsigned int u32)
: piece_(digits_, FastUInt32ToBufferLeft(u32, digits_)) {}
AlphaNum(long x)
: piece_(digits_, FastInt64ToBufferLeft(x, digits_)) {}
AlphaNum(unsigned long x)
: piece_(digits_, FastUInt64ToBufferLeft(x, digits_)) {}
AlphaNum(long long int i64)
: piece_(digits_, FastInt64ToBufferLeft(i64, digits_)) {}
AlphaNum(unsigned long long int u64)
: piece_(digits_, FastUInt64ToBufferLeft(u64, digits_)) {}
AlphaNum(float f)
: piece_(digits_, FloatToBuffer(f, digits_)) {}
AlphaNum(double f)
: piece_(digits_, DoubleToBuffer(f, digits_)) {}
AlphaNum(bfloat16 bf)
: piece_(digits_, FloatToBuffer(static_cast<float>(bf), digits_)) {}
AlphaNum(Hex hex);
AlphaNum(const char *c_str) : piece_(c_str) {}
AlphaNum(const StringPiece &pc) : piece_(pc) {}
AlphaNum(const std::string &str)
: piece_(str) {}
AlphaNum(const tstring &str)
: piece_(str) {}
template <typename A>
AlphaNum(const std::basic_string<char, std::char_traits<char>, A> &str)
: piece_(str) {}
StringPiece::size_type size() const { return piece_.size(); }
const char *data() const { return piece_.data(); }
StringPiece Piece() const { return piece_; }
private:
StringPiece piece_;
char digits_[kFastToBufferSize];
AlphaNum(char c);
AlphaNum(const AlphaNum &) = delete;
void operator=(const AlphaNum &) = delete;
};
std::string StrCat(const AlphaNum &a) TF_MUST_USE_RESULT;
std::string StrCat(const AlphaNum &a, const AlphaNum &b) TF_MUST_USE_RESULT;
std::string StrCat(const AlphaNum &a, const AlphaNum &b,
const AlphaNum &c) TF_MUST_USE_RESULT;
std::string StrCat(const AlphaNum &a, const AlphaNum &b, const AlphaNum &c,
const AlphaNum &d) TF_MUST_USE_RESULT;
namespace internal {
std::string CatPieces(std::initializer_list<StringPiece> pieces);
void AppendPieces(std::string *dest, std::initializer_list<StringPiece> pieces);
}
template <typename... AV>
std::string StrCat(const AlphaNum &a, const AlphaNum &b, const AlphaNum &c,
const AlphaNum &d, const AlphaNum &e,
const AV &...args) TF_MUST_USE_RESULT;
template <typename... AV>
std::string StrCat(const AlphaNum &a, const AlphaNum &b, const AlphaNum &c,
const AlphaNum &d, const AlphaNum &e, const AV &...args) {
return internal::CatPieces({a.Piece(), b.Piece(), c.Piece(), d.Piece(),
e.Piece(),
static_cast<const AlphaNum &>(args).Piece()...});
}
void StrAppend(std::string *dest, const AlphaNum &a);
void StrAppend(std::string *dest, const AlphaNum &a, const AlphaNum &b);
void StrAppend(std::string *dest, const AlphaNum &a, const AlphaNum &b,
const AlphaNum &c);
void StrAppend(std::string *dest, const AlphaNum &a, const AlphaNum &b,
const AlphaNum &c, const AlphaNum &d);
template <typename... AV>
inline void StrAppend(std::string *dest, const AlphaNum &a, const AlphaNum &b,
const AlphaNum &c, const AlphaNum &d, const AlphaNum &e,
const AV &...args) {
internal::AppendPieces(dest,
{a.Piece(), b.Piece(), c.Piece(), d.Piece(), e.Piece(),
static_cast<const AlphaNum &>(args).Piece()...});
}
}
}
#endif
#include "tsl/platform/strcat.h"
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include "absl/meta/type_traits.h"
#include "tsl/platform/logging.h"
namespace tsl {
namespace strings {
AlphaNum::AlphaNum(Hex hex) {
char *const end = &digits_[kFastToBufferSize];
char *writer = end;
uint64 value = hex.value;
uint64 width = hex.spec;
uint64 mask = (static_cast<uint64>(1) << (width - 1) * 4) | value;
static const char hexdigits[] = "0123456789abcdef";
do {
*--writer = hexdigits[value & 0xF];
value >>= 4;
mask >>= 4;
} while (mask != 0);
piece_ = StringPiece(writer, end - writer);
}
static char *Append1(char *out, const AlphaNum &x) {
if (x.data() == nullptr) return out;
memcpy(out, x.data(), x.size());
return out + x.size();
}
static char *Append2(char *out, const AlphaNum &x1, const AlphaNum &x2) {
if (x1.data() != nullptr) {
memcpy(out, x1.data(), x1.size());
out += x1.size();
}
if (x2.data() == nullptr) return out;
memcpy(out, x2.data(), x2.size());
return out + x2.size();
}
static char *Append4(char *out, const AlphaNum &x1, const AlphaNum &x2,
const AlphaNum &x3, const AlphaNum &x4) {
if (x1.data() != nullptr) {
memcpy(out, x1.data(), x1.size());
out += x1.size();
}
if (x2.data() != nullptr) {
memcpy(out, x2.data(), x2.size());
out += x2.size();
}
if (x3.data() != nullptr) {
memcpy(out, x3.data(), x3.size());
out += x3.size();
}
if (x4.data() == nullptr) return out;
memcpy(out, x4.data(), x4.size());
return out + x4.size();
}
string StrCat(const AlphaNum &a) { return string(a.data(), a.size()); }
string StrCat(const AlphaNum &a, const AlphaNum &b) {
string result(a.size() + b.size(), '\0');
char *const begin = &*result.begin();
char *out = Append2(begin, a, b);
DCHECK_EQ(out, begin + result.size());
return result;
}
string StrCat(const AlphaNum &a, const AlphaNum &b, const AlphaNum &c) {
string result(a.size() + b.size() + c.size(), '\0');
char *const begin = &*result.begin();
char *out = Append2(begin, a, b);
out = Append1(out, c);
DCHECK_EQ(out, begin + result.size());
return result;
}
string StrCat(const AlphaNum &a, const AlphaNum &b, const AlphaNum &c,
const AlphaNum &d) {
string result(a.size() + b.size() + c.size() + d.size(), '\0');
char *const begin = &*result.begin();
char *out = Append4(begin, a, b, c, d);
DCHECK_EQ(out, begin + result.size());
return result;
}
namespace {
template <typename string_type, typename = void>
struct ResizeUninitializedTraits {
using HasMember = std::false_type;
static void Resize(string_type *s, size_t new_size) { s->resize(new_size); }
};
template <typename string_type>
struct ResizeUninitializedTraits<
string_type, absl::void_t<decltype(std::declval<string_type &>()
.__resize_default_init(237))> > {
using HasMember = std::true_type;
static void Resize(string_type *s, size_t new_size) {
s->__resize_default_init(new_size);
}
};
static inline void STLStringResizeUninitialized(string *s, size_t new_size) {
ResizeUninitializedTraits<string>::Resize(s, new_size);
}
template <typename string_type>
void STLStringReserveAmortized(string_type *s, size_t new_size) {
const size_t cap = s->capacity();
if (new_size > cap) {
s->reserve((std::max)(new_size, 2 * cap));
}
}
template <typename string_type>
void STLStringResizeUninitializedAmortized(string_type *s, size_t new_size) {
STLStringReserveAmortized(s, new_size);
STLStringResizeUninitialized(s, new_size);
}
}
namespace internal {
string CatPieces(std::initializer_list<StringPiece> pieces) {
size_t total_size = 0;
for (const StringPiece piece : pieces) total_size += piece.size();
string result(total_size, '\0');
char *const begin = &*result.begin();
char *out = begin;
for (const StringPiece piece : pieces) {
const size_t this_size = piece.size();
memcpy(out, piece.data(), this_size);
out += this_size;
}
DCHECK_EQ(out, begin + result.size());
return result;
}
#define DCHECK_NO_OVERLAP(dest, src) \
DCHECK_GE(uintptr_t((src).data() - (dest).data()), uintptr_t((dest).size()))
void AppendPieces(string *result, std::initializer_list<StringPiece> pieces) {
size_t old_size = result->size();
size_t total_size = old_size;
for (const StringPiece piece : pieces) {
DCHECK_NO_OVERLAP(*result, piece);
total_size += piece.size();
}
STLStringResizeUninitializedAmortized(result, total_size);
char *const begin = &*result->begin();
char *out = begin + old_size;
for (const StringPiece piece : pieces) {
const size_t this_size = piece.size();
memcpy(out, piece.data(), this_size);
out += this_size;
}
DCHECK_EQ(out, begin + result->size());
}
}
void StrAppend(string *result, const AlphaNum &a) {
DCHECK_NO_OVERLAP(*result, a);
result->append(a.data(), a.size());
}
void StrAppend(string *result, const AlphaNum &a, const AlphaNum &b) {
DCHECK_NO_OVERLAP(*result, a);
DCHECK_NO_OVERLAP(*result, b);
string::size_type old_size = result->size();
STLStringResizeUninitializedAmortized(result, old_size + a.size() + b.size());
char *const begin = &*result->begin();
char *out = Append2(begin + old_size, a, b);
DCHECK_EQ(out, begin + result->size());
}
void StrAppend(string *result, const AlphaNum &a, const AlphaNum &b,
const AlphaNum &c) {
DCHECK_NO_OVERLAP(*result, a);
DCHECK_NO_OVERLAP(*result, b);
DCHECK_NO_OVERLAP(*result, c);
string::size_type old_size = result->size();
STLStringResizeUninitializedAmortized(
result, old_size + a.size() + b.size() + c.size());
char *const begin = &*result->begin();
char *out = Append2(begin + old_size, a, b);
out = Append1(out, c);
DCHECK_EQ(out, begin + result->size());
}
void StrAppend(string *result, const AlphaNum &a, const AlphaNum &b,
const AlphaNum &c, const AlphaNum &d) {
DCHECK_NO_OVERLAP(*result, a);
DCHECK_NO_OVERLAP(*result, b);
DCHECK_NO_OVERLAP(*result, c);
DCHECK_NO_OVERLAP(*result, d);
string::size_type old_size = result->size();
STLStringResizeUninitializedAmortized(
result, old_size + a.size() + b.size() + c.size() + d.size());
char *const begin = &*result->begin();
char *out = Append4(begin + old_size, a, b, c, d);
DCHECK_EQ(out, begin + result->size());
}
}
} | #include "tsl/platform/strcat.h"
#include <string>
#include "absl/strings/string_view.h"
#include "tsl/platform/stringprintf.h"
#include "tsl/platform/test.h"
#include "tsl/platform/types.h"
#ifdef _MSC_VER
typedef ptrdiff_t ssize_t;
#endif
namespace tsl {
namespace strings {
TEST(StrCat, Ints) {
const int16_t s = -1;
const uint16 us = 2;
const int i = -3;
const unsigned int ui = 4;
const int32_t l = -5;
const uint32 ul = 6;
const int64_t ll = -7;
const uint64 ull = 8;
const ptrdiff_t ptrdiff = -9;
const size_t size = 10;
const ssize_t ssize = -11;
const intptr_t intptr = -12;
const uintptr_t uintptr = 13;
string answer;
answer = StrCat(s, us);
EXPECT_EQ(answer, "-12");
answer = StrCat(i, ui);
EXPECT_EQ(answer, "-34");
answer = StrCat(l, ul);
EXPECT_EQ(answer, "-56");
answer = StrCat(ll, ull);
EXPECT_EQ(answer, "-78");
answer = StrCat(ptrdiff, size);
EXPECT_EQ(answer, "-910");
answer = StrCat(ssize, intptr);
EXPECT_EQ(answer, "-11-12");
answer = StrCat(uintptr, 0);
EXPECT_EQ(answer, "130");
}
TEST(StrCat, Floats) {
const int s = 0;
const float f = 1.5f;
const double d = 1.5;
const bfloat16 bf(1.5f);
string answer;
answer = StrCat(s, f);
EXPECT_EQ(answer, "01.5");
answer = StrCat(s, d);
EXPECT_EQ(answer, "01.5");
answer = StrCat(s, bf);
EXPECT_EQ(answer, "01.5");
}
TEST(StrCat, Nulls) {
string result;
absl::string_view v;
string strs[] = {"Hello", "Cruel", "World"};
result = StrCat(v);
EXPECT_EQ(result, "");
result = StrCat(strs[0], v);
EXPECT_EQ(result, "Hello");
result = StrCat(v, strs[0]);
EXPECT_EQ(result, "Hello");
result = StrCat(v, strs[0], strs[1]);
EXPECT_EQ(result, "HelloCruel");
result = StrCat(strs[0], v, strs[1]);
EXPECT_EQ(result, "HelloCruel");
result = StrCat(strs[0], strs[1], v);
EXPECT_EQ(result, "HelloCruel");
result = StrCat(v, strs[0], strs[1], strs[2]);
EXPECT_EQ(result, "HelloCruelWorld");
result = StrCat(strs[0], v, strs[1], strs[2]);
EXPECT_EQ(result, "HelloCruelWorld");
result = StrCat(strs[0], strs[1], v, strs[2]);
EXPECT_EQ(result, "HelloCruelWorld");
result = StrCat(strs[0], strs[1], strs[2], v);
EXPECT_EQ(result, "HelloCruelWorld");
}
TEST(StrCat, Basics) {
string result;
string strs[] = {"Hello", "Cruel", "World"};
StringPiece pieces[] = {"Hello", "Cruel", "World"};
const char *c_strs[] = {"Hello", "Cruel", "World"};
int32 i32s[] = {'H', 'C', 'W'};
uint64 ui64s[] = {12345678910LL, 10987654321LL};
result = StrCat(false, true, 2, 3);
EXPECT_EQ(result, "0123");
result = StrCat(-1);
EXPECT_EQ(result, "-1");
result = StrCat(0.5);
EXPECT_EQ(result, "0.5");
result = StrCat(strs[1], pieces[2]);
EXPECT_EQ(result, "CruelWorld");
result = StrCat(strs[0], ", ", pieces[2]);
EXPECT_EQ(result, "Hello, World");
result = StrCat(strs[0], ", ", strs[1], " ", strs[2], "!");
EXPECT_EQ(result, "Hello, Cruel World!");
result = StrCat(pieces[0], ", ", pieces[1], " ", pieces[2]);
EXPECT_EQ(result, "Hello, Cruel World");
result = StrCat(c_strs[0], ", ", c_strs[1], " ", c_strs[2]);
EXPECT_EQ(result, "Hello, Cruel World");
result = StrCat("ASCII ", i32s[0], ", ", i32s[1], " ", i32s[2], "!");
EXPECT_EQ(result, "ASCII 72, 67 87!");
result = StrCat(ui64s[0], ", ", ui64s[1], "!");
EXPECT_EQ(result, "12345678910, 10987654321!");
string one = "1";
result = StrCat("And a ", one.size(), " and a ", &result[2] - &result[0],
" and a ", one, " 2 3 4", "!");
EXPECT_EQ(result, "And a 1 and a 2 and a 1 2 3 4!");
result = StrCat("To output a char by ASCII/numeric value, use +: ", '!' + 0);
EXPECT_EQ(result, "To output a char by ASCII/numeric value, use +: 33");
float f = 100000.5;
result = StrCat("A hundred K and a half is ", f);
EXPECT_EQ(result, "A hundred K and a half is 100000.5");
double d = f;
d *= d;
result = StrCat("A hundred K and a half squared is ", d);
EXPECT_EQ(result, "A hundred K and a half squared is 10000100000.25");
result = StrCat(1, 2, 333, 4444, 55555, 666666, 7777777, 88888888, 999999999);
EXPECT_EQ(result, "12333444455555666666777777788888888999999999");
}
TEST(StrCat, MaxArgs) {
string result;
result = StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a");
EXPECT_EQ(result, "123456789a");
result = StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b");
EXPECT_EQ(result, "123456789ab");
result = StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c");
EXPECT_EQ(result, "123456789abc");
result = StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d");
EXPECT_EQ(result, "123456789abcd");
result = StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e");
EXPECT_EQ(result, "123456789abcde");
result = StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f");
EXPECT_EQ(result, "123456789abcdef");
result = StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f", "g");
EXPECT_EQ(result, "123456789abcdefg");
result =
StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f", "g", "h");
EXPECT_EQ(result, "123456789abcdefgh");
result = StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f", "g",
"h", "i");
EXPECT_EQ(result, "123456789abcdefghi");
result = StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f", "g",
"h", "i", "j");
EXPECT_EQ(result, "123456789abcdefghij");
result = StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f", "g",
"h", "i", "j", "k");
EXPECT_EQ(result, "123456789abcdefghijk");
result = StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f", "g",
"h", "i", "j", "k", "l");
EXPECT_EQ(result, "123456789abcdefghijkl");
result = StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f", "g",
"h", "i", "j", "k", "l", "m");
EXPECT_EQ(result, "123456789abcdefghijklm");
result = StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f", "g",
"h", "i", "j", "k", "l", "m", "n");
EXPECT_EQ(result, "123456789abcdefghijklmn");
result = StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f", "g",
"h", "i", "j", "k", "l", "m", "n", "o");
EXPECT_EQ(result, "123456789abcdefghijklmno");
result = StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f", "g",
"h", "i", "j", "k", "l", "m", "n", "o", "p");
EXPECT_EQ(result, "123456789abcdefghijklmnop");
result = StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f", "g",
"h", "i", "j", "k", "l", "m", "n", "o", "p", "q");
EXPECT_EQ(result, "123456789abcdefghijklmnopq");
result = StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, "a", "b", "c", "d", "e", "f",
"g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r",
"s", "t", "u", "v", "w", "x", "y", "z", "A", "B", "C", "D",
"E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P",
"Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z");
EXPECT_EQ(result,
"12345678910abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
}
TEST(StrAppend, Basics) {
string result = "existing text";
string strs[] = {"Hello", "Cruel", "World"};
StringPiece pieces[] = {"Hello", "Cruel", "World"};
const char *c_strs[] = {"Hello", "Cruel", "World"};
int32 i32s[] = {'H', 'C', 'W'};
uint64 ui64s[] = {12345678910LL, 10987654321LL};
string::size_type old_size = result.size();
StrAppend(&result, strs[0]);
EXPECT_EQ(result.substr(old_size), "Hello");
old_size = result.size();
StrAppend(&result, strs[1], pieces[2]);
EXPECT_EQ(result.substr(old_size), "CruelWorld");
old_size = result.size();
StrAppend(&result, strs[0], ", ", pieces[2]);
EXPECT_EQ(result.substr(old_size), "Hello, World");
old_size = result.size();
StrAppend(&result, strs[0], ", ", strs[1], " ", strs[2], "!");
EXPECT_EQ(result.substr(old_size), "Hello, Cruel World!");
old_size = result.size();
StrAppend(&result, pieces[0], ", ", pieces[1], " ", pieces[2]);
EXPECT_EQ(result.substr(old_size), "Hello, Cruel World");
old_size = result.size();
StrAppend(&result, c_strs[0], ", ", c_strs[1], " ", c_strs[2]);
EXPECT_EQ(result.substr(old_size), "Hello, Cruel World");
old_size = result.size();
StrAppend(&result, "ASCII ", i32s[0], ", ", i32s[1], " ", i32s[2], "!");
EXPECT_EQ(result.substr(old_size), "ASCII 72, 67 87!");
old_size = result.size();
StrAppend(&result, ui64s[0], ", ", ui64s[1], "!");
EXPECT_EQ(result.substr(old_size), "12345678910, 10987654321!");
string one = "1";
old_size = result.size();
StrAppend(&result, "And a ", one.size(), " and a ", &result[2] - &result[0],
" and a ", one, " 2 3 4", "!");
EXPECT_EQ(result.substr(old_size), "And a 1 and a 2 and a 1 2 3 4!");
old_size = result.size();
StrAppend(&result,
"To output a char by ASCII/numeric value, use +: ", '!' + 0);
EXPECT_EQ(result.substr(old_size),
"To output a char by ASCII/numeric value, use +: 33");
float f = 100000.5;
old_size = result.size();
StrAppend(&result, "A hundred K and a half is ", f);
EXPECT_EQ(result.substr(old_size), "A hundred K and a half is 100000.5");
double d = f;
d *= d;
old_size = result.size();
StrAppend(&result, "A hundred K and a half squared is ", d);
EXPECT_EQ(result.substr(old_size),
"A hundred K and a half squared is 10000100000.25");
old_size = result.size();
StrAppend(&result, 1, 22, 333, 4444, 55555, 666666, 7777777, 88888888, 9);
EXPECT_EQ(result.substr(old_size), "1223334444555556666667777777888888889");
old_size = result.size();
StrAppend(&result, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, "a", "b", "c", "d", "e",
"f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r",
"s", "t", "u", "v", "w", "x", "y", "z", "A", "B", "C", "D", "E",
"F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R",
"S", "T", "U", "V", "W", "X", "Y", "Z",
"No limit thanks to C++11's variadic templates");
EXPECT_EQ(result.substr(old_size),
"12345678910abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
"No limit thanks to C++11's variadic templates");
}
TEST(StrAppend, Death) {
string s = "self";
EXPECT_DEBUG_DEATH(StrAppend(&s, s.c_str() + 1), "Check failed:");
EXPECT_DEBUG_DEATH(StrAppend(&s, s), "Check failed:");
}
static void CheckHex64(uint64 v) {
string actual = StrCat(Hex(v, kZeroPad16));
string expected = Printf("%016llx", static_cast<unsigned long long>(v));
EXPECT_EQ(expected, actual) << " decimal value " << v;
actual = StrCat(Hex(v, kZeroPad8));
expected = Printf("%08llx", static_cast<unsigned long long>(v));
EXPECT_EQ(expected, actual) << " decimal value " << v;
actual = StrCat(Hex(v));
expected = Printf("%llx", static_cast<unsigned long long>(v));
EXPECT_EQ(expected, actual) << " decimal value " << v;
}
static void CheckHex32(uint32 v) {
string actual = StrCat(Hex(v, kZeroPad8));
string expected = Printf("%08x", v);
EXPECT_EQ(expected, actual) << " decimal value " << v;
actual = StrCat(Hex(v));
expected = Printf("%x", v);
EXPECT_EQ(expected, actual) << " decimal value " << v;
}
static void CheckHexSigned32(int32_t v) {
string actual = StrCat(Hex(v, kZeroPad8));
string expected = Printf("%08x", v);
EXPECT_EQ(expected, actual) << " decimal value " << v;
actual = StrCat(Hex(v));
expected = Printf("%x", v);
EXPECT_EQ(expected, actual) << " decimal value " << v;
}
static void TestFastPrints() {
for (int i = 0; i < 10000; i++) {
CheckHex64(i);
CheckHex32(i);
CheckHexSigned32(i);
CheckHexSigned32(-i);
}
CheckHex64(0x123456789abcdef0ull);
CheckHex32(0x12345678);
int8_t minus_one_8bit = -1;
EXPECT_EQ("ff", StrCat(Hex(minus_one_8bit)));
int16_t minus_one_16bit = -1;
EXPECT_EQ("ffff", StrCat(Hex(minus_one_16bit)));
}
TEST(Numbers, TestFunctionsMovedOverFromNumbersMain) { TestFastPrints(); }
}
} |
2,601 | cpp | google/tsl | hash | tsl/platform/hash.cc | tsl/platform/hash_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_HASH_H_
#define TENSORFLOW_TSL_PLATFORM_HASH_H_
#include <stddef.h>
#include <stdint.h>
#include <functional>
#include <string>
#include "tsl/platform/stringpiece.h"
#include "tsl/platform/types.h"
namespace tsl {
extern uint32 Hash32(const char* data, size_t n, uint32 seed);
extern uint64 Hash64(const char* data, size_t n, uint64 seed);
inline uint64 Hash64(const char* data, size_t n) {
return Hash64(data, n, 0xDECAFCAFFE);
}
inline uint64 Hash64(const char* data) { return Hash64(data, ::strlen(data)); }
inline uint64 Hash64(const std::string& str) {
return Hash64(str.data(), str.size());
}
inline uint64 Hash64(const tstring& str) {
return Hash64(str.data(), str.size());
}
inline uint64 Hash64Combine(uint64 a, uint64 b) {
return a ^ (b + 0x9e3779b97f4a7800ULL + (a << 10) + (a >> 4));
}
inline uint64 Hash64CombineUnordered(uint64 a, uint64 b) { return a + b; }
template <typename T, typename = void>
struct hash {
size_t operator()(const T& t) const { return std::hash<T>()(t); }
};
template <typename T>
struct hash<T, typename std::enable_if<std::is_enum<T>::value>::type> {
size_t operator()(T value) const {
return std::hash<uint64>()(static_cast<uint64>(value));
}
};
template <typename T>
struct hash<T*> {
size_t operator()(const T* t) const {
size_t k = static_cast<size_t>(reinterpret_cast<uintptr_t>(t));
return k + (k >> 6);
}
};
template <>
struct hash<string> {
size_t operator()(const string& s) const {
return static_cast<size_t>(Hash64(s));
}
};
template <>
struct hash<tstring> {
size_t operator()(const tstring& s) const {
return static_cast<size_t>(Hash64(s.data(), s.size()));
}
};
template <>
struct hash<StringPiece> {
size_t operator()(StringPiece sp) const {
return static_cast<size_t>(Hash64(sp.data(), sp.size()));
}
};
using StringPieceHasher = ::tsl::hash<StringPiece>;
template <typename T, typename U>
struct hash<std::pair<T, U>> {
size_t operator()(const std::pair<T, U>& p) const {
return Hash64Combine(hash<T>()(p.first), hash<U>()(p.second));
}
};
}
namespace std {
template <>
struct hash<tsl::tstring> {
size_t operator()(const tsl::tstring& s) const {
return static_cast<size_t>(tsl::Hash64(s.data(), s.size()));
}
};
}
#endif
#include "tsl/platform/hash.h"
#include <string.h>
#include "tsl/platform/macros.h"
#include "tsl/platform/raw_coding.h"
#include "tsl/platform/types.h"
namespace tsl {
static inline uint32 ByteAs32(char c) { return static_cast<uint32>(c) & 0xff; }
static inline uint64 ByteAs64(char c) { return static_cast<uint64>(c) & 0xff; }
uint32 Hash32(const char* data, size_t n, uint32 seed) {
const uint32 m = 0x5bd1e995;
const int r = 24;
uint32 h = seed ^ n;
while (n >= 4) {
uint32 k = core::DecodeFixed32(data);
k *= m;
k ^= k >> r;
k *= m;
h *= m;
h ^= k;
data += 4;
n -= 4;
}
switch (n) {
case 3:
h ^= ByteAs32(data[2]) << 16;
TF_FALLTHROUGH_INTENDED;
case 2:
h ^= ByteAs32(data[1]) << 8;
TF_FALLTHROUGH_INTENDED;
case 1:
h ^= ByteAs32(data[0]);
h *= m;
}
h ^= h >> 13;
h *= m;
h ^= h >> 15;
return h;
}
uint64 Hash64(const char* data, size_t n, uint64 seed) {
const uint64 m = 0xc6a4a7935bd1e995;
const int r = 47;
uint64 h = seed ^ (n * m);
while (n >= 8) {
uint64 k = core::DecodeFixed64(data);
data += 8;
n -= 8;
k *= m;
k ^= k >> r;
k *= m;
h ^= k;
h *= m;
}
switch (n) {
case 7:
h ^= ByteAs64(data[6]) << 48;
TF_FALLTHROUGH_INTENDED;
case 6:
h ^= ByteAs64(data[5]) << 40;
TF_FALLTHROUGH_INTENDED;
case 5:
h ^= ByteAs64(data[4]) << 32;
TF_FALLTHROUGH_INTENDED;
case 4:
h ^= ByteAs64(data[3]) << 24;
TF_FALLTHROUGH_INTENDED;
case 3:
h ^= ByteAs64(data[2]) << 16;
TF_FALLTHROUGH_INTENDED;
case 2:
h ^= ByteAs64(data[1]) << 8;
TF_FALLTHROUGH_INTENDED;
case 1:
h ^= ByteAs64(data[0]);
h *= m;
}
h ^= h >> r;
h *= m;
h ^= h >> r;
return h;
}
} | #include <map>
#include <unordered_map>
#include <vector>
#include "tsl/platform/hash.h"
#include "tsl/platform/logging.h"
#include "tsl/platform/test.h"
#include "tsl/platform/test_benchmark.h"
namespace tsl {
TEST(Hash, SignedUnsignedIssue) {
const unsigned char d1[1] = {0x62};
const unsigned char d2[2] = {0xc3, 0x97};
const unsigned char d3[3] = {0xe2, 0x99, 0xa5};
const unsigned char d4[4] = {0xe1, 0x80, 0xb9, 0x32};
const unsigned char d5[48] = {
0x01, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x18, 0x28, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
struct Case {
uint32 hash32;
uint64 hash64;
const unsigned char* data;
size_t size;
uint32 seed;
};
for (Case c : std::vector<Case>{
{0x471a8188u, 0x4c61ea3eeda4cb87ull, nullptr, 0, 0xbc9f1d34},
{0xd615eba5u, 0x091309f7ef916c8aull, d1, sizeof(d1), 0xbc9f1d34},
{0x0c3cccdau, 0xa815bcdf1d1af01cull, d2, sizeof(d2), 0xbc9f1d34},
{0x3ba37e0eu, 0x02167564e4d06430ull, d3, sizeof(d3), 0xbc9f1d34},
{0x16174eb3u, 0x8f7ed82ffc21071full, d4, sizeof(d4), 0xbc9f1d34},
{0x98b1926cu, 0xce196580c97aff1eull, d5, sizeof(d5), 0x12345678},
}) {
EXPECT_EQ(c.hash32,
Hash32(reinterpret_cast<const char*>(c.data), c.size, c.seed));
EXPECT_EQ(c.hash64,
Hash64(reinterpret_cast<const char*>(c.data), c.size, c.seed));
for (int align = 1; align <= 7; align++) {
std::string input(align, 'x');
input.append(reinterpret_cast<const char*>(c.data), c.size);
EXPECT_EQ(c.hash32, Hash32(&input[align], c.size, c.seed));
EXPECT_EQ(c.hash64, Hash64(&input[align], c.size, c.seed));
}
}
}
TEST(Hash, HashPtrIsNotIdentityFunction) {
int* ptr = reinterpret_cast<int*>(0xcafe0000);
EXPECT_NE(hash<int*>()(ptr), size_t{0xcafe0000});
}
static void BM_Hash32(::testing::benchmark::State& state) {
int len = state.range(0);
std::string input(len, 'x');
uint32 h = 0;
for (auto s : state) {
h = Hash32(input.data(), len, 1);
}
state.SetBytesProcessed(state.iterations() * len);
VLOG(1) << h;
}
BENCHMARK(BM_Hash32)->Range(1, 1024);
TEST(StringPieceHasher, Equality) {
StringPieceHasher hasher;
StringPiece s1("foo");
StringPiece s2("bar");
StringPiece s3("baz");
StringPiece s4("zot");
EXPECT_TRUE(hasher(s1) != hasher(s2));
EXPECT_TRUE(hasher(s1) != hasher(s3));
EXPECT_TRUE(hasher(s1) != hasher(s4));
EXPECT_TRUE(hasher(s2) != hasher(s3));
EXPECT_TRUE(hasher(s2) != hasher(s4));
EXPECT_TRUE(hasher(s3) != hasher(s4));
EXPECT_TRUE(hasher(s1) == hasher(s1));
EXPECT_TRUE(hasher(s2) == hasher(s2));
EXPECT_TRUE(hasher(s3) == hasher(s3));
EXPECT_TRUE(hasher(s4) == hasher(s4));
}
TEST(StringPieceHasher, HashMap) {
string s1("foo");
string s2("bar");
string s3("baz");
StringPiece p1(s1);
StringPiece p2(s2);
StringPiece p3(s3);
std::unordered_map<StringPiece, int, StringPieceHasher> map;
map.insert(std::make_pair(p1, 0));
map.insert(std::make_pair(p2, 1));
map.insert(std::make_pair(p3, 2));
EXPECT_EQ(map.size(), 3);
bool found[3] = {false, false, false};
for (auto const& val : map) {
int x = val.second;
EXPECT_TRUE(x >= 0 && x < 3);
EXPECT_TRUE(!found[x]);
found[x] = true;
}
EXPECT_EQ(found[0], true);
EXPECT_EQ(found[1], true);
EXPECT_EQ(found[2], true);
auto new_iter = map.find("zot");
EXPECT_TRUE(new_iter == map.end());
new_iter = map.find("bar");
EXPECT_TRUE(new_iter != map.end());
map.erase(new_iter);
EXPECT_EQ(map.size(), 2);
found[0] = false;
found[1] = false;
found[2] = false;
for (const auto& iter : map) {
int x = iter.second;
EXPECT_TRUE(x >= 0 && x < 3);
EXPECT_TRUE(!found[x]);
found[x] = true;
}
EXPECT_EQ(found[0], true);
EXPECT_EQ(found[1], false);
EXPECT_EQ(found[2], true);
}
} |
2,602 | cpp | google/tsl | setround | tsl/platform/setround.cc | tsl/platform/setround_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_SETROUND_H_
#define TENSORFLOW_TSL_PLATFORM_SETROUND_H_
#if defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
#define TF_BROKEN_CFENV
#endif
#if defined(TF_BROKEN_CFENV)
#include <fenv.h>
#else
#include <cfenv>
#endif
#include "tsl/platform/macros.h"
namespace tsl {
namespace port {
class ScopedSetRound {
public:
ScopedSetRound(int mode);
~ScopedSetRound();
private:
int original_mode_;
ScopedSetRound(const ScopedSetRound&) = delete;
void operator=(const ScopedSetRound&) = delete;
};
}
}
#endif
#include "tsl/platform/setround.h"
#include "tsl/platform/logging.h"
namespace tsl {
namespace port {
#if defined(TF_BROKEN_CFENV)
ScopedSetRound::ScopedSetRound(const int mode) : original_mode_(mode) {
DCHECK_EQ(mode, FE_TONEAREST);
}
ScopedSetRound::~ScopedSetRound() {}
#else
ScopedSetRound::ScopedSetRound(const int mode) {
original_mode_ = std::fegetround();
if (original_mode_ < 0) {
original_mode_ = FE_TONEAREST;
}
std::fesetround(mode);
}
ScopedSetRound::~ScopedSetRound() { std::fesetround(original_mode_); }
#endif
}
} | #include "tsl/platform/setround.h"
#include <cmath>
#include "tsl/platform/test.h"
#if !defined(__clang__) || !defined(__OPTIMIZE__)
namespace tsl {
namespace {
void CheckDownward() {
EXPECT_EQ(12, std::nearbyint(12.0));
EXPECT_EQ(12, std::nearbyint(12.1));
EXPECT_EQ(-13, std::nearbyint(-12.1));
EXPECT_EQ(12, std::nearbyint(12.5));
EXPECT_EQ(12, std::nearbyint(12.9));
EXPECT_EQ(-13, std::nearbyint(-12.9));
EXPECT_EQ(13, std::nearbyint(13.0));
}
void CheckToNearest() {
EXPECT_EQ(12, std::nearbyint(12.0));
EXPECT_EQ(12, std::nearbyint(12.1));
EXPECT_EQ(-12, std::nearbyint(-12.1));
EXPECT_EQ(12, std::nearbyint(12.5));
EXPECT_EQ(13, std::nearbyint(12.9));
EXPECT_EQ(-13, std::nearbyint(-12.9));
EXPECT_EQ(13, std::nearbyint(13.0));
}
void CheckTowardZero() {
EXPECT_EQ(12, std::nearbyint(12.0));
EXPECT_EQ(12, std::nearbyint(12.1));
EXPECT_EQ(-12, std::nearbyint(-12.1));
EXPECT_EQ(12, std::nearbyint(12.5));
EXPECT_EQ(12, std::nearbyint(12.9));
EXPECT_EQ(-12, std::nearbyint(-12.9));
EXPECT_EQ(13, std::nearbyint(13.0));
}
void CheckUpward() {
EXPECT_EQ(12, std::nearbyint(12.0));
EXPECT_EQ(13, std::nearbyint(12.1));
EXPECT_EQ(-12, std::nearbyint(-12.1));
EXPECT_EQ(13, std::nearbyint(12.5));
EXPECT_EQ(13, std::nearbyint(12.9));
EXPECT_EQ(-12, std::nearbyint(-12.9));
EXPECT_EQ(13, std::nearbyint(13.0));
}
TEST(SetScopedSetRound, Downward) {
port::ScopedSetRound round(FE_DOWNWARD);
CheckDownward();
}
TEST(SetScopedSetRound, ToNearest) {
port::ScopedSetRound round(FE_TONEAREST);
CheckToNearest();
}
TEST(SetScopedSetRound, TowardZero) {
port::ScopedSetRound round(FE_TOWARDZERO);
CheckTowardZero();
}
TEST(SetScopedSetRound, Upward) {
port::ScopedSetRound round(FE_UPWARD);
CheckUpward();
}
TEST(SetScopedSetRound, Scoped) {
std::fesetround(FE_TONEAREST);
CheckToNearest();
{
port::ScopedSetRound round(FE_UPWARD);
CheckUpward();
}
CheckToNearest();
}
}
}
#endif |
2,603 | cpp | google/tsl | path | tsl/platform/path.cc | tsl/platform/path_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_PATH_H_
#define TENSORFLOW_TSL_PLATFORM_PATH_H_
#include <string>
#include "tsl/platform/stringpiece.h"
#include "tsl/platform/types.h"
namespace tsl {
namespace io {
namespace internal {
std::string JoinPathImpl(std::initializer_list<tsl::StringPiece> paths);
}
#ifndef SWIG
template <typename... T>
std::string JoinPath(const T&... args) {
return internal::JoinPathImpl({args...});
}
#endif
bool IsAbsolutePath(tsl::StringPiece path);
tsl::StringPiece Dirname(tsl::StringPiece path);
tsl::StringPiece Basename(tsl::StringPiece path);
tsl::StringPiece Extension(tsl::StringPiece path);
tsl::StringPiece BasenamePrefix(tsl::StringPiece path);
std::string CommonPathPrefix(absl::Span<std::string const> paths);
std::string CleanPath(tsl::StringPiece path);
void ParseURI(tsl::StringPiece uri, tsl::StringPiece* scheme,
tsl::StringPiece* host, tsl::StringPiece* path);
std::string CreateURI(tsl::StringPiece scheme, tsl::StringPiece host,
tsl::StringPiece path);
std::string GetTempFilename(const std::string& extension);
bool GetTestWorkspaceDir(std::string* dir);
bool GetTestUndeclaredOutputsDir(std::string* dir);
bool ResolveTestPrefixes(tsl::StringPiece path, std::string& resolved_path);
[[maybe_unused]] std::string& AppendDotExeIfWindows(std::string& path);
}
}
#endif
#include "tsl/platform/path.h"
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#if defined(PLATFORM_WINDOWS)
#include <windows.h>
#else
#include <unistd.h>
#endif
#include <string>
#include <vector>
#include "absl/algorithm/container.h"
#include "tsl/platform/logging.h"
#include "tsl/platform/mutex.h"
#include "tsl/platform/scanner.h"
#include "tsl/platform/str_util.h"
#include "tsl/platform/strcat.h"
#include "tsl/platform/stringpiece.h"
#include "tsl/platform/types.h"
namespace tsl {
namespace io {
namespace internal {
namespace {
const char kPathSep[] = "/";
}
string JoinPathImpl(std::initializer_list<StringPiece> paths) {
string result;
for (StringPiece path : paths) {
if (path.empty()) continue;
if (result.empty()) {
result = string(path);
continue;
}
if (IsAbsolutePath(path)) path = path.substr(1);
if (result[result.size() - 1] == kPathSep[0]) {
strings::StrAppend(&result, path);
} else {
strings::StrAppend(&result, kPathSep, path);
}
}
return result;
}
std::pair<StringPiece, StringPiece> SplitPath(StringPiece uri) {
StringPiece scheme, host, path;
ParseURI(uri, &scheme, &host, &path);
auto pos = path.rfind('/');
#ifdef PLATFORM_WINDOWS
if (pos == StringPiece::npos) pos = path.rfind('\\');
#endif
if (pos == StringPiece::npos)
return std::make_pair(StringPiece(uri.data(), host.end() - uri.begin()),
path);
if (pos == 0)
return std::make_pair(
StringPiece(uri.data(), path.begin() + 1 - uri.begin()),
StringPiece(path.data() + 1, path.size() - 1));
return std::make_pair(
StringPiece(uri.data(), path.begin() + pos - uri.begin()),
StringPiece(path.data() + pos + 1, path.size() - (pos + 1)));
}
std::pair<StringPiece, StringPiece> SplitBasename(StringPiece path) {
path = Basename(path);
auto pos = path.rfind('.');
if (pos == StringPiece::npos)
return std::make_pair(path, StringPiece(path.data() + path.size(), 0));
return std::make_pair(
StringPiece(path.data(), pos),
StringPiece(path.data() + pos + 1, path.size() - (pos + 1)));
}
}
bool IsAbsolutePath(StringPiece path) {
return !path.empty() && path[0] == '/';
}
StringPiece Dirname(StringPiece path) {
return internal::SplitPath(path).first;
}
StringPiece Basename(StringPiece path) {
return internal::SplitPath(path).second;
}
StringPiece Extension(StringPiece path) {
return internal::SplitBasename(path).second;
}
StringPiece BasenamePrefix(StringPiece path) {
return internal::SplitBasename(path).first;
}
string CleanPath(StringPiece unclean_path) {
string path(unclean_path);
const char* src = path.c_str();
string::iterator dst = path.begin();
const bool is_absolute_path = *src == '/';
if (is_absolute_path) {
*dst++ = *src++;
while (*src == '/') ++src;
}
string::const_iterator backtrack_limit = dst;
while (*src) {
bool parsed = false;
if (src[0] == '.') {
if (src[1] == '/' || !src[1]) {
if (*++src) {
++src;
}
parsed = true;
} else if (src[1] == '.' && (src[2] == '/' || !src[2])) {
src += 2;
if (dst != backtrack_limit) {
for (--dst; dst != backtrack_limit && dst[-1] != '/'; --dst) {
}
} else if (!is_absolute_path) {
src -= 2;
*dst++ = *src++;
*dst++ = *src++;
if (*src) {
*dst++ = *src;
}
backtrack_limit = dst;
}
if (*src) {
++src;
}
parsed = true;
}
}
if (!parsed) {
while (*src && *src != '/') {
*dst++ = *src++;
}
if (*src) {
*dst++ = *src++;
}
}
while (*src == '/') {
++src;
}
}
string::difference_type path_length = dst - path.begin();
if (path_length != 0) {
if (path_length > 1 && path[path_length - 1] == '/') {
--path_length;
}
path.resize(path_length);
} else {
path.assign(1, '.');
}
return path;
}
void ParseURI(StringPiece uri, StringPiece* scheme, StringPiece* host,
StringPiece* path) {
if (!strings::Scanner(uri)
.One(strings::Scanner::LETTER)
.Many(strings::Scanner::LETTER_DIGIT_DOT)
.StopCapture()
.OneLiteral(":
.GetResult(&uri, scheme)) {
*scheme = StringPiece(uri.data(), 0);
*host = StringPiece(uri.data(), 0);
*path = uri;
return;
}
if (!strings::Scanner(uri).ScanUntil('/').GetResult(&uri, host)) {
*host = uri;
*path = StringPiece();
return;
}
*path = uri;
}
string CreateURI(StringPiece scheme, StringPiece host, StringPiece path) {
if (scheme.empty()) {
return string(path);
}
return strings::StrCat(scheme, ":
}
int64_t UniqueId() {
static mutex mu(LINKER_INITIALIZED);
static int64_t id = 0;
mutex_lock l(mu);
return ++id;
}
string CommonPathPrefix(absl::Span<const string> paths) {
if (paths.empty()) return "";
size_t min_filename_size =
absl::c_min_element(paths, [](const string& a, const string& b) {
return a.size() < b.size();
})->size();
if (min_filename_size == 0) return "";
size_t common_prefix_size = [&] {
for (size_t prefix_size = 0; prefix_size < min_filename_size;
prefix_size++) {
char c = paths[0][prefix_size];
for (int f = 1; f < paths.size(); f++) {
if (paths[f][prefix_size] != c) {
return prefix_size;
}
}
}
return min_filename_size;
}();
size_t rpos = absl::string_view(paths[0])
.substr(0, common_prefix_size)
.rfind(internal::kPathSep);
return rpos == std::string::npos
? ""
: std::string(absl::string_view(paths[0]).substr(0, rpos + 1));
}
string GetTempFilename(const string& extension) {
#if defined(__ANDROID__)
LOG(FATAL) << "GetTempFilename is not implemented in this platform.";
#elif defined(PLATFORM_WINDOWS)
char temp_dir[_MAX_PATH];
DWORD retval;
retval = GetTempPath(_MAX_PATH, temp_dir);
if (retval > _MAX_PATH || retval == 0) {
LOG(FATAL) << "Cannot get the directory for temporary files.";
}
char temp_file_name[_MAX_PATH];
retval = GetTempFileName(temp_dir, "", UniqueId(), temp_file_name);
if (retval > _MAX_PATH || retval == 0) {
LOG(FATAL) << "Cannot get a temporary file in: " << temp_dir;
}
string full_tmp_file_name(temp_file_name);
full_tmp_file_name.append(extension);
return full_tmp_file_name;
#else
for (const char* dir : std::vector<const char*>(
{getenv("TEST_TMPDIR"), getenv("TMPDIR"), getenv("TMP"), "/tmp"})) {
if (!dir || !dir[0]) {
continue;
}
struct stat statbuf;
if (!stat(dir, &statbuf) && S_ISDIR(statbuf.st_mode)) {
string tmp_filepath;
int fd;
if (extension.length()) {
tmp_filepath = io::JoinPath(
dir, strings::StrCat("tmp_file_tensorflow_", UniqueId(), "_XXXXXX.",
extension));
fd = mkstemps(&tmp_filepath[0], extension.length() + 1);
} else {
tmp_filepath = io::JoinPath(
dir,
strings::StrCat("tmp_file_tensorflow_", UniqueId(), "_XXXXXX"));
fd = mkstemp(&tmp_filepath[0]);
}
if (fd < 0) {
LOG(FATAL) << "Failed to create temp file.";
} else {
if (close(fd) < 0) {
LOG(ERROR) << "close() failed: " << strerror(errno);
}
return tmp_filepath;
}
}
}
LOG(FATAL) << "No temp directory found.";
std::abort();
#endif
}
namespace {
bool StartsWithSegment(tsl::StringPiece path, tsl::StringPiece segment) {
return tsl::str_util::StartsWith(path, segment) &&
(path.size() == segment.size() ||
path.at(segment.size()) == internal::kPathSep[0]);
}
}
bool GetTestWorkspaceDir(string* dir) {
const char* srcdir = getenv("TEST_SRCDIR");
if (srcdir == nullptr) {
return false;
}
const char* workspace = getenv("TEST_WORKSPACE");
if (workspace == nullptr) {
return false;
}
if (dir != nullptr) {
*dir = tsl::io::JoinPath(srcdir, workspace);
}
return true;
}
bool GetTestUndeclaredOutputsDir(string* dir) {
const char* outputs_dir = getenv("TEST_UNDECLARED_OUTPUTS_DIR");
if (outputs_dir == nullptr) {
return false;
}
if (dir != nullptr) {
*dir = outputs_dir;
}
return true;
}
bool ResolveTestPrefixes(tsl::StringPiece path, string& resolved_path) {
constexpr tsl::StringPiece kTestWorkspaceSegment = "TEST_WORKSPACE";
constexpr tsl::StringPiece kOutputDirSegment = "TEST_UNDECLARED_OUTPUTS_DIR";
if (StartsWithSegment(path, kTestWorkspaceSegment)) {
if (!GetTestWorkspaceDir(&resolved_path)) {
return false;
}
resolved_path += path.substr(kTestWorkspaceSegment.size());
return true;
} else if (StartsWithSegment(path, kOutputDirSegment)) {
if (!GetTestUndeclaredOutputsDir(&resolved_path)) {
return false;
}
resolved_path += path.substr(kOutputDirSegment.size());
return true;
} else {
resolved_path = path;
return true;
}
}
[[maybe_unused]] std::string& AppendDotExeIfWindows(std::string& path) {
#ifdef PLATFORM_WINDOWS
path.append(".exe");
#endif
return path;
}
}
} | #include "tsl/platform/path.h"
#include <string>
#include "tsl/platform/env.h"
#include "tsl/platform/stringpiece.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace io {
TEST(PathTest, JoinPath) {
EXPECT_EQ("/foo/bar", JoinPath("/foo", "bar"));
EXPECT_EQ("foo/bar", JoinPath("foo", "bar"));
EXPECT_EQ("foo/bar", JoinPath("foo", "/bar"));
EXPECT_EQ("/foo/bar", JoinPath("/foo", "/bar"));
EXPECT_EQ("/bar", JoinPath("", "/bar"));
EXPECT_EQ("bar", JoinPath("", "bar"));
EXPECT_EQ("/foo", JoinPath("/foo", ""));
EXPECT_EQ("/foo/bar/baz/blah/blink/biz",
JoinPath("/foo/bar/baz/", "/blah/blink/biz"));
EXPECT_EQ("/foo/bar/baz/blah", JoinPath("/foo", "bar", "baz", "blah"));
}
TEST(PathTest, IsAbsolutePath) {
EXPECT_FALSE(IsAbsolutePath(""));
EXPECT_FALSE(IsAbsolutePath("../foo"));
EXPECT_FALSE(IsAbsolutePath("foo"));
EXPECT_FALSE(IsAbsolutePath("./foo"));
EXPECT_FALSE(IsAbsolutePath("foo/bar/baz/"));
EXPECT_TRUE(IsAbsolutePath("/foo"));
EXPECT_TRUE(IsAbsolutePath("/foo/bar/../baz"));
}
TEST(PathTest, Dirname) {
EXPECT_EQ("hdfs:
Dirname("hdfs:
EXPECT_EQ("/hello", Dirname("/hello/"));
EXPECT_EQ("/", Dirname("/hello"));
EXPECT_EQ("hello", Dirname("hello/world"));
EXPECT_EQ("hello", Dirname("hello/"));
EXPECT_EQ("", Dirname("world"));
EXPECT_EQ("/", Dirname("/"));
EXPECT_EQ("", Dirname(""));
}
TEST(PathTest, Basename) {
EXPECT_EQ("", Basename("/hello/"));
EXPECT_EQ("hello", Basename("/hello"));
EXPECT_EQ("world", Basename("hello/world"));
EXPECT_EQ("", Basename("hello/"));
EXPECT_EQ("world", Basename("world"));
EXPECT_EQ("", Basename("/"));
EXPECT_EQ("", Basename(""));
}
TEST(PathTest, Extension) {
EXPECT_EQ("gif", Extension("foo.gif"));
EXPECT_EQ("", Extension("foo."));
EXPECT_EQ("", Extension(""));
EXPECT_EQ("", Extension("/"));
EXPECT_EQ("", Extension("foo"));
EXPECT_EQ("", Extension("foo/"));
EXPECT_EQ("gif", Extension("/a/path/to/foo.gif"));
EXPECT_EQ("html", Extension("/a/path.bar/to/foo.html"));
EXPECT_EQ("", Extension("/a/path.bar/to/foo"));
EXPECT_EQ("baz", Extension("/a/path.bar/to/foo.bar.baz"));
}
TEST(PathTest, CleanPath) {
EXPECT_EQ(".", CleanPath(""));
EXPECT_EQ("x", CleanPath("x"));
EXPECT_EQ("/a/b/c/d", CleanPath("/a/b/c/d"));
EXPECT_EQ("/a/b/c/dtrue);
tsl::setenv("TEST_WORKSPACE", "my/workspace", true);
EXPECT_TRUE(GetTestWorkspaceDir(&dir));
EXPECT_EQ(dir, "/repo/src/my/workspace");
EXPECT_TRUE(GetTestWorkspaceDir(nullptr));
dir = kOriginalValue;
tsl::unsetenv("TEST_SRCDIR");
tsl::setenv("TEST_WORKSPACE", "my/workspace", true);
EXPECT_FALSE(GetTestWorkspaceDir(&dir));
EXPECT_EQ(dir, kOriginalValue);
EXPECT_FALSE(GetTestWorkspaceDir(nullptr));
dir = kOriginalValue;
tsl::setenv("TEST_SRCDIR", "/repo/src", true);
tsl::unsetenv("TEST_WORKSPACE");
EXPECT_FALSE(GetTestWorkspaceDir(&dir));
EXPECT_EQ(dir, kOriginalValue);
EXPECT_FALSE(GetTestWorkspaceDir(nullptr));
dir = kOriginalValue;
tsl::unsetenv("TEST_SRCDIR");
tsl::unsetenv("TEST_WORKSPACE");
EXPECT_FALSE(GetTestWorkspaceDir(&dir));
EXPECT_EQ(dir, kOriginalValue);
EXPECT_FALSE(GetTestWorkspaceDir(nullptr));
}
TEST(PathTest, GetTestUndeclaredOutputsDir) {
constexpr tsl::StringPiece kOriginalValue = "original value";
std::string dir;
dir = kOriginalValue;
tsl::setenv("TEST_UNDECLARED_OUTPUTS_DIR", "/test/outputs",
true);
EXPECT_TRUE(GetTestUndeclaredOutputsDir(&dir));
EXPECT_EQ(dir, "/test/outputs");
EXPECT_TRUE(GetTestUndeclaredOutputsDir(nullptr));
dir = kOriginalValue;
tsl::unsetenv("TEST_UNDECLARED_OUTPUTS_DIR");
EXPECT_FALSE(GetTestUndeclaredOutputsDir(&dir));
EXPECT_EQ(dir, kOriginalValue);
EXPECT_FALSE(GetTestUndeclaredOutputsDir(nullptr));
}
TEST(PathTest, ResolveTestPrefixesKeepsThePathUnchanged) {
constexpr tsl::StringPiece kOriginalValue = "original value";
std::string resolved_path;
resolved_path = kOriginalValue;
EXPECT_TRUE(ResolveTestPrefixes("", resolved_path));
EXPECT_EQ(resolved_path, "");
resolved_path = kOriginalValue;
EXPECT_TRUE(ResolveTestPrefixes("/", resolved_path));
EXPECT_EQ(resolved_path, "/");
resolved_path = kOriginalValue;
EXPECT_TRUE(ResolveTestPrefixes("alpha/beta", resolved_path));
EXPECT_EQ(resolved_path, "alpha/beta");
resolved_path = kOriginalValue;
EXPECT_TRUE(ResolveTestPrefixes("/alpha/beta", resolved_path));
EXPECT_EQ(resolved_path, "/alpha/beta");
}
TEST(PathTest, ResolveTestPrefixesCanResolveTestWorkspace) {
constexpr tsl::StringPiece kOriginalValue = "original value";
std::string resolved_path;
tsl::setenv("TEST_SRCDIR", "/repo/src", true);
tsl::setenv("TEST_WORKSPACE", "my/workspace", true);
resolved_path = kOriginalValue;
EXPECT_TRUE(ResolveTestPrefixes("TEST_WORKSPACE", resolved_path));
EXPECT_EQ(resolved_path, "/repo/src/my/workspace");
resolved_path = kOriginalValue;
EXPECT_TRUE(ResolveTestPrefixes("TEST_WORKSPACE/", resolved_path));
EXPECT_EQ(resolved_path, "/repo/src/my/workspace/");
resolved_path = kOriginalValue;
EXPECT_TRUE(ResolveTestPrefixes("TEST_WORKSPACE/a/b", resolved_path));
EXPECT_EQ(resolved_path, "/repo/src/my/workspace/a/b");
resolved_path = kOriginalValue;
EXPECT_TRUE(ResolveTestPrefixes("TEST_WORKSPACEE", resolved_path));
EXPECT_EQ(resolved_path, "TEST_WORKSPACEE");
resolved_path = kOriginalValue;
EXPECT_TRUE(ResolveTestPrefixes("/TEST_WORKSPACE", resolved_path));
EXPECT_EQ(resolved_path, "/TEST_WORKSPACE");
}
TEST(PathTest, ResolveTestPrefixesCannotResolveTestWorkspace) {
constexpr tsl::StringPiece kOriginalValue = "original value";
std::string resolved_path;
tsl::unsetenv("TEST_SRCDIR");
tsl::unsetenv("TEST_WORKSPACE");
resolved_path = kOriginalValue;
EXPECT_FALSE(ResolveTestPrefixes("TEST_WORKSPACE", resolved_path));
EXPECT_EQ(resolved_path, kOriginalValue);
}
TEST(PathTest, ResolveTestPrefixesCanResolveTestUndeclaredOutputsDir) {
constexpr tsl::StringPiece kOriginalValue = "original value";
std::string resolved_path;
tsl::setenv("TEST_UNDECLARED_OUTPUTS_DIR", "/test/outputs",
true);
resolved_path = kOriginalValue;
EXPECT_TRUE(
ResolveTestPrefixes("TEST_UNDECLARED_OUTPUTS_DIR", resolved_path));
EXPECT_EQ(resolved_path, "/test/outputs");
resolved_path = kOriginalValue;
EXPECT_TRUE(
ResolveTestPrefixes("TEST_UNDECLARED_OUTPUTS_DIR/", resolved_path));
EXPECT_EQ(resolved_path, "/test/outputs/");
resolved_path = kOriginalValue;
EXPECT_TRUE(
ResolveTestPrefixes("TEST_UNDECLARED_OUTPUTS_DIR/a/b", resolved_path));
EXPECT_EQ(resolved_path, "/test/outputs/a/b");
resolved_path = kOriginalValue;
EXPECT_TRUE(
ResolveTestPrefixes("TEST_UNDECLARED_OUTPUTS_DIRR", resolved_path));
EXPECT_EQ(resolved_path, "TEST_UNDECLARED_OUTPUTS_DIRR");
resolved_path = kOriginalValue;
EXPECT_TRUE(
ResolveTestPrefixes("/TEST_UNDECLARED_OUTPUTS_DIR", resolved_path));
EXPECT_EQ(resolved_path, "/TEST_UNDECLARED_OUTPUTS_DIR");
}
TEST(PathTest, ResolveTestPrefixesCannotResolveTestUndeclaredOutputsDir) {
constexpr tsl::StringPiece kOriginalValue = "original value";
std::string resolved_path;
tsl::unsetenv("TEST_UNDECLARED_OUTPUTS_DIR");
resolved_path = kOriginalValue;
EXPECT_FALSE(
ResolveTestPrefixes("TEST_UNDECLARED_OUTPUTS_DIR", resolved_path));
EXPECT_EQ(resolved_path, kOriginalValue);
}
}
} |
2,604 | cpp | google/tsl | status | tsl/platform/status.cc | tsl/platform/status_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_DEFAULT_STATUS_H_
#define TENSORFLOW_TSL_PLATFORM_DEFAULT_STATUS_H_
#define MAYBE_ADD_SOURCE_LOCATION(status) \
{}
#define ADD_SOURCE_LOCATION(status) status
#endif
#include "tsl/platform/status.h"
#include <stdio.h>
#include <deque>
#include <functional>
#include <memory>
#include <ostream>
#include <sstream>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#include "absl/base/call_once.h"
#include "absl/functional/function_ref.h"
#include "absl/status/status.h"
#include "absl/strings/cord.h"
#include "absl/strings/escaping.h"
#include "absl/strings/match.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_join.h"
#include "absl/strings/str_replace.h"
#include "absl/strings/str_split.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "tsl/platform/mutex.h"
#include "tsl/platform/stack_frame.h"
#include "tsl/platform/stacktrace.h"
#include "tsl/platform/str_util.h"
#include "tsl/platform/strcat.h"
#include "tsl/platform/stringprintf.h"
#include "tsl/protobuf/error_codes.pb.h"
namespace tsl {
namespace {
class StatusLogSink : public TFLogSink {
public:
static StatusLogSink* GetInstance() {
static StatusLogSink* sink = new StatusLogSink();
return sink;
}
void enable() {
absl::call_once(flag_, [this] {
num_messages_ = 5;
if (const char* num_msgs_str =
getenv("TF_WORKER_NUM_FORWARDED_LOG_MESSAGES")) {
if (!absl::SimpleAtoi(num_msgs_str, &num_messages_)) {
LOG(WARNING) << "Failed to parse env variable "
"TF_WORKER_NUM_WARNING_ERROR_LOG_IN_STATUS="
<< num_msgs_str << " as int. Using the default value "
<< num_messages_ << ".";
}
}
if (num_messages_ > 0) {
TFAddLogSink(this);
}
});
}
void GetMessages(std::vector<std::string>* logs) TF_LOCKS_EXCLUDED(mu_) {
mutex_lock lock(mu_);
for (auto& msg : messages_) {
logs->push_back(msg);
}
}
void Send(const TFLogEntry& entry) override TF_LOCKS_EXCLUDED(mu_) {
if (entry.log_severity() < absl::LogSeverity::kWarning) return;
mutex_lock lock(mu_);
messages_.emplace_back(entry.ToString());
if (messages_.size() > static_cast<size_t>(num_messages_)) {
messages_.pop_front();
}
}
private:
mutex mu_;
absl::once_flag flag_;
int num_messages_ = 0;
std::deque<std::string> messages_ TF_GUARDED_BY(mu_);
};
}
namespace errors {
static constexpr const char kStackTraceProtoUrl[] =
"type.googleapis.com/tensorflow.StackTracePayload";
void SetStackTrace(absl::Status& status, std::vector<StackFrame> stack_trace) {
std::vector<std::string> items;
items.reserve(stack_trace.size());
for (StackFrame& frame : stack_trace) {
items.push_back(
absl::StrCat(absl::StrReplaceAll(frame.file_name, {{"\n", ""}}), "\n",
frame.line_number, "\n",
absl::StrReplaceAll(frame.function_name, {{"\n", ""}})));
}
status.SetPayload(kStackTraceProtoUrl,
absl::Cord(absl::StrJoin(items, "\n")));
}
std::vector<StackFrame> GetStackTrace(const absl::Status& status) {
std::vector<StackFrame> stack_trace;
absl::optional<absl::Cord> maybe_serialized_payload =
status.GetPayload(kStackTraceProtoUrl);
if (maybe_serialized_payload.has_value()) {
std::vector<std::string> split =
absl::StrSplit(maybe_serialized_payload.value().Flatten(), '\n');
assert(split.size() % 3 == 0);
for (int i = 0; i < split.size() / 3; ++i) {
const int idx = 3 * i;
int line_number = -1;
CHECK(absl::SimpleAtoi(split[idx + 1], &line_number));
stack_trace.emplace_back(std::move(split[idx]), line_number,
std::move(split[idx + 2]));
}
}
return stack_trace;
}
}
#ifdef _WIN32
const char* NullTerminatedMessage(const absl::Status& status) {
return absl::StatusMessageAsCStr(status);
}
#endif
std::string* TfCheckOpHelperOutOfLine(const absl::Status& v, const char* msg) {
std::stringstream ss;
ss << "Non-OK-status: " << msg << "\nStatus: " << v;
return new std::string(ss.str());
}
StatusGroup::StatusGroup() {}
StatusGroup::StatusGroup(std::initializer_list<absl::Status> statuses) {
for (const absl::Status& s : statuses) {
Update(s);
}
}
static constexpr const char kDerivedStatusProtoUrl[] =
"type.googleapis.com/tensorflow.DerivedStatus";
absl::Status StatusGroup::MakeDerived(const absl::Status& s) {
if (IsDerived(s)) {
return s;
} else {
absl::Status derived(s);
derived.SetPayload(kDerivedStatusProtoUrl, absl::Cord(""));
return derived;
}
}
bool StatusGroup::IsDerived(const absl::Status& s) {
return s.GetPayload(kDerivedStatusProtoUrl).has_value();
}
void StatusGroup::ConfigureLogHistory() {
StatusLogSink::GetInstance()->enable();
}
void StatusGroup::Update(const absl::Status& s) {
if (s.ok()) {
++num_ok_;
} else {
ok_ = false;
if (IsDerived(s)) {
derived_.insert(s);
} else {
non_derived_.insert(s);
}
}
}
static constexpr int kMaxAggregatedStatusMessageSize = 8 * 1024;
static constexpr int kMaxAttachedLogMessageSize = 512;
std::unordered_map<std::string, absl::Cord> StatusGroup::GetPayloads() const {
std::unordered_map<std::string, absl::Cord> payloads;
auto capture_payload = [&payloads](absl::string_view key,
const absl::Cord& value) {
payloads[std::string(key)] = value;
};
for (const auto& status : derived_) {
status.ForEachPayload(capture_payload);
}
for (const auto& status : non_derived_) {
status.ForEachPayload(capture_payload);
}
payloads.erase(kDerivedStatusProtoUrl);
return payloads;
}
absl::Status MakeStatus(
absl::StatusCode code, absl::string_view message,
const std::unordered_map<std::string, absl::Cord>& payloads) {
absl::Status status(code, message);
for (const auto& payload : payloads) {
status.SetPayload(payload.first, payload.second);
}
return status;
}
std::string MakeString(const absl::Status& status) {
return absl::StrCat(absl::StatusCodeToString(status.code()), ": ",
status.message());
}
absl::Status StatusGroup::as_summary_status() const {
if (ok_) {
return absl::OkStatus();
}
auto get_recent_logs = [this]() -> std::string {
if (!recent_logs_.empty()) {
std::vector<std::string> fmt;
fmt.push_back("\nRecent warning and error logs:");
for (auto& log : recent_logs_) {
fmt.push_back(" " + log.substr(0, kMaxAttachedLogMessageSize));
}
return absl::StrJoin(fmt, "\n");
} else {
return "";
}
};
if (non_derived_.size() == 1) {
return MakeStatus(
non_derived_.begin()->code(),
strings::StrCat(non_derived_.begin()->message(), get_recent_logs()),
GetPayloads());
}
if (!non_derived_.empty()) {
std::vector<std::string> fmt;
fmt.push_back(
strings::Printf("%zu root error(s) found.", non_derived_.size()));
int index = 0;
auto code = absl::StatusCode::kCancelled;
for (const auto& s : non_derived_) {
if (code == absl::StatusCode::kCancelled &&
s.code() != absl::StatusCode::kCancelled) {
code = s.code();
}
fmt.emplace_back(strings::StrCat(" (", index, ") ", MakeString(s)));
++index;
}
fmt.push_back(strings::Printf("%zu successful operations.", num_ok_));
fmt.push_back(
strings::Printf("%zu derived errors ignored.", derived_.size()));
std::string error_msg =
absl::StrJoin(fmt, "\n").substr(0, kMaxAggregatedStatusMessageSize);
return MakeStatus(code, strings::StrCat(error_msg, get_recent_logs()),
GetPayloads());
} else {
return MakeDerived(MakeStatus(derived_.begin()->code(),
derived_.begin()->message(), GetPayloads()));
}
}
absl::Status StatusGroup::as_concatenated_status() const {
if (ok_) {
return absl::OkStatus();
}
if (non_derived_.size() == 1) {
return MakeStatus(non_derived_.begin()->code(),
non_derived_.begin()->message(), GetPayloads());
}
if (!non_derived_.empty()) {
std::vector<string> fmt;
fmt.emplace_back("\n=====================");
for (const auto& s : non_derived_) {
fmt.emplace_back(MakeString(s));
}
fmt.emplace_back("=====================\n");
return MakeStatus(
non_derived_.begin()->code(),
absl::StrJoin(fmt, "\n").substr(0, kMaxAggregatedStatusMessageSize),
GetPayloads());
} else {
return MakeDerived(MakeStatus(derived_.begin()->code(),
derived_.begin()->message(), GetPayloads()));
}
}
void StatusGroup::AttachLogMessages() {
recent_logs_.clear();
StatusLogSink::GetInstance()->GetMessages(&recent_logs_);
}
} | #include "tsl/platform/status.h"
#include <unordered_map>
#include <vector>
#include "absl/status/status.h"
#include "absl/strings/cord.h"
#include "absl/strings/str_format.h"
#include "tsl/platform/errors.h"
#include "tsl/platform/stack_frame.h"
#include "tsl/platform/status_matchers.h"
#include "tsl/platform/status_to_from_proto.h"
#include "tsl/platform/test.h"
#include "tsl/protobuf/error_codes.pb.h"
#include "tsl/protobuf/status.pb.h"
namespace tsl {
namespace {
using ::testing::IsEmpty;
using ::tsl::testing::IsOk;
using ::tsl::testing::StatusIs;
TEST(ToStringTest, PayloadsArePrinted) {
absl::Status status = errors::Aborted("Aborted Error Message");
status.SetPayload("payload_key", absl::Cord(absl::StrFormat(
"payload_value %c%c%c", 1, 2, 3)));
EXPECT_EQ(status.ToString(),
"ABORTED: Aborted Error Message [payload_key='payload_value "
"\\x01\\x02\\x03']");
}
TEST(ToStringTest, MatchesAbslStatus) {
absl::Status status = errors::Aborted("Aborted Error Message");
status.SetPayload("payload_key", absl::Cord(absl::StrFormat(
"payload_value %c%c%c", 1, 2, 3)));
absl::Status absl_status =
absl::Status(absl::StatusCode::kAborted, status.message());
absl_status.SetPayload("payload_key", absl::Cord(absl::StrFormat(
"payload_value %c%c%c", 1, 2, 3)));
EXPECT_EQ(status.ToString(), absl_status.ToString());
}
TEST(StackTrace, SerializeAndDeserializeCorrectly) {
absl::Status status = errors::Aborted("Aborted Error Message");
std::vector<StackFrame> stack_trace;
stack_trace.push_back(StackFrame("filename_1", 33, "func_name_1"));
stack_trace.push_back(StackFrame("filename_2", 66, "func_name_2"));
errors::SetStackTrace(status, stack_trace);
std::vector<StackFrame> deserialized = errors::GetStackTrace(status);
EXPECT_EQ(stack_trace.size(), deserialized.size());
for (size_t i = 0; i < stack_trace.size(); ++i) {
EXPECT_EQ(stack_trace[i], deserialized[i]);
}
}
TEST(StatusGroupTest, DeterministicOrderWithoutPayloads) {
absl::Status status_a = errors::Aborted("Status A");
absl::Status status_b = errors::Aborted("Status B");
absl::Status status_c = errors::Aborted("Status C");
absl::Status combined =
StatusGroup({status_a, status_b, status_c}).as_summary_status();
EXPECT_EQ(combined,
StatusGroup({status_a, status_b, status_c}).as_summary_status());
EXPECT_EQ(combined,
StatusGroup({status_a, status_c, status_b}).as_summary_status());
EXPECT_EQ(combined,
StatusGroup({status_b, status_a, status_c}).as_summary_status());
EXPECT_EQ(combined,
StatusGroup({status_b, status_c, status_a}).as_summary_status());
EXPECT_EQ(combined,
StatusGroup({status_c, status_a, status_b}).as_summary_status());
EXPECT_EQ(combined,
StatusGroup({status_c, status_b, status_a}).as_summary_status());
}
TEST(StatusGroupTest, DeterministicOrderWithPayloads) {
absl::Status status_a = errors::Aborted("Status A");
status_a.SetPayload("payload_key", absl::Cord("payload_value_a"));
absl::Status status_b = errors::Aborted("Status B");
status_b.SetPayload("payload_key", absl::Cord("payload_value_b"));
absl::Status status_c = errors::Aborted("Status C");
status_c.SetPayload("payload_key", absl::Cord("payload_value_c"));
absl::Status combined =
StatusGroup({status_a, status_b, status_c}).as_summary_status();
ASSERT_TRUE(combined.GetPayload("payload_key").has_value());
std::string payload(combined.GetPayload("payload_key").value());
EXPECT_EQ(payload, StatusGroup({status_a, status_b, status_c})
.as_summary_status()
.GetPayload("payload_key"));
EXPECT_EQ(payload, StatusGroup({status_a, status_c, status_b})
.as_summary_status()
.GetPayload("payload_key"));
EXPECT_EQ(payload, StatusGroup({status_b, status_a, status_c})
.as_summary_status()
.GetPayload("payload_key"));
EXPECT_EQ(payload, StatusGroup({status_b, status_c, status_a})
.as_summary_status()
.GetPayload("payload_key"));
EXPECT_EQ(payload, StatusGroup({status_c, status_a, status_b})
.as_summary_status()
.GetPayload("payload_key"));
EXPECT_EQ(payload, StatusGroup({status_c, status_b, status_a})
.as_summary_status()
.GetPayload("payload_key"));
}
TEST(StatusGroupTest, PayloadsMergedProperly) {
absl::Status status_a = errors::Aborted("Status A");
status_a.SetPayload("payload_key_a",
absl::Cord(std::string("payload_value_a")));
absl::Status status_b = errors::Aborted("Status B");
status_b.SetPayload("payload_key_b",
absl::Cord(std::string("payload_value_b")));
absl::Status status_c = errors::Aborted("Status C");
status_c.SetPayload("payload_key_c",
absl::Cord(std::string("payload_value_c")));
absl::Status derived_status_c =
StatusGroup::MakeDerived(errors::Aborted("Status C"));
derived_status_c.SetPayload(
"payload_key_c", absl::Cord(std::string("derived_payload_value_c")));
StatusGroup status_group({status_a, status_b, status_c, derived_status_c});
EXPECT_THAT(status_group.GetPayloads(), ::testing::SizeIs(3));
absl::Status combined = status_group.as_summary_status();
EXPECT_EQ(combined.GetPayload("payload_key_a"), "payload_value_a");
EXPECT_EQ(combined.GetPayload("payload_key_b"), "payload_value_b");
EXPECT_EQ(combined.GetPayload("payload_key_c"), "payload_value_c");
}
TEST(Status, ErrorStatusForEachPayloadIteratesOverAll) {
absl::Status s(absl::StatusCode::kInternal, "Error message");
s.SetPayload("key1", absl::Cord("value1"));
s.SetPayload("key2", absl::Cord("value2"));
s.SetPayload("key3", absl::Cord("value3"));
std::unordered_map<std::string, absl::Cord> payloads;
s.ForEachPayload([&payloads](StringPiece key, const absl::Cord& value) {
payloads[std::string(key)] = value;
});
EXPECT_EQ(payloads.size(), 3);
EXPECT_EQ(payloads["key1"], "value1");
EXPECT_EQ(payloads["key2"], "value2");
EXPECT_EQ(payloads["key3"], "value3");
}
TEST(Status, OkStatusForEachPayloadNoIteration) {
absl::Status s = absl::OkStatus();
s.SetPayload("key1", absl::Cord("value1"));
s.SetPayload("key2", absl::Cord("value2"));
s.SetPayload("key3", absl::Cord("value3"));
std::unordered_map<std::string, absl::Cord> payloads;
s.ForEachPayload([&payloads](StringPiece key, const absl::Cord& value) {
payloads[std::string(key)] = value;
});
EXPECT_EQ(payloads.size(), 0);
}
TEST(Status, SaveOKStatusToProto) {
tensorflow::StatusProto status_proto = StatusToProto(absl::OkStatus());
EXPECT_EQ(status_proto.code(), error::OK);
EXPECT_THAT(status_proto.message(), IsEmpty());
}
TEST(Status, SaveErrorStatusToProto) {
tensorflow::StatusProto status_proto =
StatusToProto(errors::NotFound("Not found"));
EXPECT_EQ(status_proto.code(), error::NOT_FOUND);
EXPECT_EQ(status_proto.message(), "Not found");
}
TEST(Status, SaveEmptyStatusToProto) {
tensorflow::StatusProto status_proto = StatusToProto(absl::Status());
EXPECT_EQ(status_proto.code(), error::OK);
EXPECT_THAT(status_proto.message(), IsEmpty());
}
TEST(Status, MakeOKStatusFromProto) {
tensorflow::StatusProto status_proto;
status_proto.set_code(error::OK);
EXPECT_THAT(StatusFromProto(status_proto), IsOk());
}
TEST(Status, MakeErrorStatusFromProto) {
tensorflow::StatusProto status_proto;
status_proto.set_code(error::INVALID_ARGUMENT);
status_proto.set_message("Invalid argument");
EXPECT_THAT(StatusFromProto(status_proto),
StatusIs(error::INVALID_ARGUMENT, "Invalid argument"));
}
TEST(Status, MakeStatusFromEmptyProto) {
EXPECT_THAT(StatusFromProto(tensorflow::StatusProto()), IsOk());
}
}
} |
2,605 | cpp | google/tsl | gcs_throttle | tsl/platform/cloud/gcs_throttle.cc | tsl/platform/cloud/gcs_throttle_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_CLOUD_GCS_THROTTLE_H_
#define TENSORFLOW_TSL_PLATFORM_CLOUD_GCS_THROTTLE_H_
#include "tsl/platform/env.h"
namespace tsl {
struct GcsThrottleConfig {
bool enabled = false;
int64_t token_rate =
100000;
int64_t bucket_size = 10000000;
int64_t tokens_per_request = 100;
int64_t initial_tokens = 0;
};
class GcsThrottle {
public:
explicit GcsThrottle(EnvTime* env_time = nullptr);
bool AdmitRequest();
void RecordResponse(size_t num_bytes);
void SetConfig(GcsThrottleConfig config);
inline int64_t available_tokens() TF_LOCKS_EXCLUDED(mu_) {
mutex_lock l(mu_);
UpdateState();
return available_tokens_;
}
bool is_enabled() TF_LOCKS_EXCLUDED(mu_) {
mutex_lock l(mu_);
return config_.enabled;
}
private:
void UpdateState() TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
inline uint64 request_bytes_to_tokens(size_t num_bytes) {
return num_bytes >> 10;
}
mutex mu_;
uint64 last_updated_secs_ TF_GUARDED_BY(mu_) = 0;
int64_t available_tokens_ TF_GUARDED_BY(mu_) = 0;
EnvTime* const env_time_;
GcsThrottleConfig config_ TF_GUARDED_BY(mu_);
};
}
#endif
#include "tsl/platform/cloud/gcs_throttle.h"
#include <algorithm>
namespace tsl {
namespace {
EnvTime* get_default_env_time() {
static EnvTime* default_env_time = new EnvTime;
return default_env_time;
}
}
GcsThrottle::GcsThrottle(EnvTime* env_time)
: last_updated_secs_(env_time ? env_time->GetOverridableNowSeconds()
: EnvTime::NowSeconds()),
available_tokens_(0),
env_time_(env_time ? env_time : get_default_env_time()) {}
bool GcsThrottle::AdmitRequest() {
mutex_lock l(mu_);
UpdateState();
if (available_tokens_ < config_.tokens_per_request) {
return false || !config_.enabled;
}
available_tokens_ -= config_.tokens_per_request;
return true;
}
void GcsThrottle::RecordResponse(size_t num_bytes) {
mutex_lock l(mu_);
UpdateState();
available_tokens_ -= request_bytes_to_tokens(num_bytes);
}
void GcsThrottle::SetConfig(GcsThrottleConfig config) {
mutex_lock l(mu_);
config_ = config;
available_tokens_ = config.initial_tokens;
last_updated_secs_ = env_time_->GetOverridableNowSeconds();
}
void GcsThrottle::UpdateState() {
int64_t now = env_time_->GetOverridableNowSeconds();
uint64 delta_secs =
std::max(int64_t{0}, now - static_cast<int64_t>(last_updated_secs_));
available_tokens_ += delta_secs * config_.token_rate;
available_tokens_ = std::min(available_tokens_, config_.bucket_size);
last_updated_secs_ = now;
}
} | #include "tsl/platform/cloud/gcs_throttle.h"
#include "tsl/lib/core/status_test_util.h"
#include "tsl/platform/str_util.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace {
class TestTime : public EnvTime {
public:
uint64 GetOverridableNowNanos() const override {
return now_micros_ * kMicrosToNanos;
}
void SetTime(uint64 now_micros) { now_micros_ = now_micros; }
void AdvanceSeconds(int64_t secs) { now_micros_ += secs * kSecondsToMicros; }
private:
uint64 now_micros_ = 1234567890000000ULL;
};
class GcsThrottleTest : public ::testing::Test {
protected:
GcsThrottleTest() : throttle_(&time_) {
config_.enabled = true;
throttle_.SetConfig(config_);
}
GcsThrottleConfig config_;
TestTime time_;
GcsThrottle throttle_;
};
TEST_F(GcsThrottleTest, ReplenishTokens) {
EXPECT_EQ(0, throttle_.available_tokens());
time_.AdvanceSeconds(1);
EXPECT_EQ(100000, throttle_.available_tokens());
time_.AdvanceSeconds(2);
EXPECT_EQ(300000, throttle_.available_tokens());
}
TEST_F(GcsThrottleTest, RejectRequest) {
EXPECT_EQ(0, throttle_.available_tokens());
time_.AdvanceSeconds(1);
EXPECT_TRUE(throttle_.AdmitRequest());
EXPECT_EQ(99900, throttle_.available_tokens());
for (int i = 1; i < 1000; i++) {
EXPECT_TRUE(throttle_.AdmitRequest());
}
EXPECT_FALSE(throttle_.AdmitRequest());
}
TEST_F(GcsThrottleTest, MarkResponses) {
time_.AdvanceSeconds(1);
EXPECT_TRUE(throttle_.AdmitRequest());
throttle_.RecordResponse(128000000);
EXPECT_EQ(-25100, throttle_.available_tokens());
EXPECT_FALSE(throttle_.AdmitRequest());
time_.AdvanceSeconds(1);
EXPECT_TRUE(throttle_.AdmitRequest())
<< "Available tokens: " << throttle_.available_tokens();
}
TEST_F(GcsThrottleTest, Skippingtime_) {
EXPECT_EQ(0, throttle_.available_tokens());
time_.AdvanceSeconds(90);
EXPECT_EQ(9000000, throttle_.available_tokens());
}
TEST_F(GcsThrottleTest, BucketLimit) {
time_.AdvanceSeconds(120);
EXPECT_EQ(10000000, throttle_.available_tokens());
}
TEST_F(GcsThrottleTest, ReverseTime) {
time_.AdvanceSeconds(1);
EXPECT_EQ(100000, throttle_.available_tokens());
time_.AdvanceSeconds(-3600);
EXPECT_EQ(100000, throttle_.available_tokens());
time_.AdvanceSeconds(1);
EXPECT_EQ(200000, throttle_.available_tokens());
}
TEST(GcsThrottleDisabledTest, Disabled) {
TestTime time;
GcsThrottle throttle(&time);
ASSERT_FALSE(throttle.is_enabled());
EXPECT_EQ(0, throttle.available_tokens());
time.AdvanceSeconds(1);
EXPECT_EQ(100000, throttle.available_tokens());
EXPECT_TRUE(throttle.AdmitRequest());
EXPECT_EQ(99900, throttle.available_tokens());
time.AdvanceSeconds(1);
EXPECT_EQ(199900, throttle.available_tokens());
throttle.RecordResponse(128000000);
EXPECT_LT(0, throttle.available_tokens());
EXPECT_TRUE(throttle.AdmitRequest());
}
}
} |
2,606 | cpp | google/tsl | curl_http_request | tsl/platform/cloud/curl_http_request.cc | tsl/platform/cloud/curl_http_request_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_CLOUD_CURL_HTTP_REQUEST_H_
#define TENSORFLOW_TSL_PLATFORM_CLOUD_CURL_HTTP_REQUEST_H_
#include <string>
#include <unordered_map>
#include <vector>
#include <curl/curl.h>
#include "tsl/platform/cloud/http_request.h"
#include "tsl/platform/env.h"
#include "tsl/platform/errors.h"
#include "tsl/platform/macros.h"
#include "tsl/platform/protobuf.h"
#include "tsl/platform/status.h"
#include "tsl/platform/stringpiece.h"
#include "tsl/platform/types.h"
namespace tsl {
class LibCurl;
class CurlHttpRequest : public HttpRequest {
public:
class Factory : public HttpRequest::Factory {
public:
virtual ~Factory() {}
virtual HttpRequest* Create() { return new CurlHttpRequest(); }
};
CurlHttpRequest();
explicit CurlHttpRequest(LibCurl* libcurl)
: CurlHttpRequest(libcurl, Env::Default()) {}
CurlHttpRequest(LibCurl* libcurl, Env* env);
~CurlHttpRequest() override;
void SetUri(const string& uri) override;
void SetRange(uint64 start, uint64 end) override;
void AddHeader(const string& name, const string& value) override;
void AddResolveOverride(const string& hostname, int64_t port,
const string& ip_addr) override;
void AddAuthBearerHeader(const string& auth_token) override;
void SetRequestStats(RequestStats* stats) override;
void SetDeleteRequest() override;
Status SetPutFromFile(const string& body_filepath, size_t offset) override;
void SetPutEmptyBody() override;
void SetPostFromBuffer(const char* buffer, size_t size) override;
void SetPostEmptyBody() override;
void SetResultBuffer(std::vector<char>* out_buffer) override;
void SetResultBufferDirect(char* buffer, size_t size) override;
bool IsDirectResponse() const;
size_t GetResultBufferDirectBytesTransferred() override;
string GetResponseHeader(const string& name) const override;
uint64 GetResponseCode() const override;
Status Send() override;
string EscapeString(const string& str) override;
void SetTimeouts(uint32 connection, uint32 inactivity, uint32 total) override;
private:
static size_t WriteCallback(const void* ptr, size_t size, size_t nmemb,
void* userdata);
static size_t WriteCallbackDirect(const void* ptr, size_t size, size_t nmemb,
void* userdata);
static size_t ReadCallback(void* ptr, size_t size, size_t nmemb,
FILE* userdata);
static size_t HeaderCallback(const void* ptr, size_t size, size_t nmemb,
void* this_object);
static int ProgressCallback(void* this_object, curl_off_t dltotal,
curl_off_t dlnow, curl_off_t ultotal,
curl_off_t ulnow);
void CheckMethodNotSet() const;
void CheckNotSent() const;
StringPiece GetResponse() const;
Status CURLcodeToStatus(CURLcode code, const char* error_buffer);
LibCurl* libcurl_;
Env* env_;
FILE* put_body_ = nullptr;
StringPiece post_body_buffer_;
size_t post_body_read_ = 0;
std::vector<char>* response_buffer_ = nullptr;
struct DirectResponseState {
char* buffer_;
size_t buffer_size_;
size_t bytes_transferred_;
size_t bytes_received_;
};
DirectResponseState direct_response_ = {};
CURL* curl_ = nullptr;
curl_slist* curl_headers_ = nullptr;
curl_slist* resolve_list_ = nullptr;
RequestStats* stats_ = nullptr;
std::vector<char> default_response_buffer_;
std::unordered_map<string, string> response_headers_;
uint64 response_code_ = 0;
uint64 last_progress_timestamp_ = 0;
curl_off_t last_progress_bytes_ = 0;
uint32 inactivity_timeout_secs_ = 60;
uint32 connect_timeout_secs_ = 120;
uint32 request_timeout_secs_ = 3600;
bool is_uri_set_ = false;
bool is_method_set_ = false;
bool is_sent_ = false;
string uri_;
RequestMethod method_ = RequestMethod::kGet;
const size_t response_to_error_limit_ = 500;
CurlHttpRequest(const CurlHttpRequest&) = delete;
void operator=(const CurlHttpRequest&) = delete;
};
class LibCurl {
public:
virtual ~LibCurl() {}
virtual CURL* curl_easy_init() = 0;
virtual CURLcode curl_easy_setopt(CURL* curl, CURLoption option,
uint64 param) TF_MUST_USE_RESULT = 0;
virtual CURLcode curl_easy_setopt(CURL* curl, CURLoption option,
const char* param) TF_MUST_USE_RESULT = 0;
virtual CURLcode curl_easy_setopt(CURL* curl, CURLoption option,
void* param) TF_MUST_USE_RESULT = 0;
virtual CURLcode curl_easy_setopt(
CURL* curl, CURLoption option,
size_t (*param)(void*, size_t, size_t, FILE*)) TF_MUST_USE_RESULT = 0;
virtual CURLcode curl_easy_setopt(CURL* curl, CURLoption option,
size_t (*param)(const void*, size_t, size_t,
void*))
TF_MUST_USE_RESULT = 0;
virtual CURLcode curl_easy_setopt(
CURL* curl, CURLoption option,
int (*param)(void* clientp, curl_off_t dltotal, curl_off_t dlnow,
curl_off_t ultotal,
curl_off_t ulnow)) TF_MUST_USE_RESULT = 0;
virtual CURLcode curl_easy_perform(CURL* curl) TF_MUST_USE_RESULT = 0;
virtual CURLcode curl_easy_getinfo(CURL* curl, CURLINFO info,
uint64* value) TF_MUST_USE_RESULT = 0;
virtual CURLcode curl_easy_getinfo(CURL* curl, CURLINFO info,
double* value) TF_MUST_USE_RESULT = 0;
virtual void curl_easy_cleanup(CURL* curl) = 0;
virtual curl_slist* curl_slist_append(curl_slist* list, const char* str) = 0;
virtual void curl_slist_free_all(curl_slist* list) = 0;
virtual char* curl_easy_escape(CURL* curl, const char* str, int length) = 0;
virtual void curl_free(void* p) = 0;
};
}
#endif
#include "tsl/platform/cloud/curl_http_request.h"
#include <algorithm>
#include "xla/tsl/util/env_var.h"
#include "tsl/lib/gtl/map_util.h"
#include "tsl/platform/errors.h"
#include "tsl/platform/macros.h"
#include "tsl/platform/scanner.h"
#include "tsl/platform/str_util.h"
#include "tsl/platform/types.h"
#define CHECK_CURL_OK(expr) CHECK_EQ(expr, CURLE_OK)
namespace tsl {
namespace {
constexpr uint64 kVerboseOutput = 0;
class LibCurlProxy : public LibCurl {
public:
static LibCurlProxy* Load() {
static LibCurlProxy* libcurl = []() -> LibCurlProxy* {
curl_global_init(CURL_GLOBAL_ALL);
return new LibCurlProxy;
}();
return libcurl;
}
CURL* curl_easy_init() override { return ::curl_easy_init(); }
CURLcode curl_easy_setopt(CURL* curl, CURLoption option,
uint64 param) override {
return ::curl_easy_setopt(curl, option, param);
}
CURLcode curl_easy_setopt(CURL* curl, CURLoption option,
const char* param) override {
return ::curl_easy_setopt(curl, option, param);
}
CURLcode curl_easy_setopt(CURL* curl, CURLoption option,
void* param) override {
return ::curl_easy_setopt(curl, option, param);
}
CURLcode curl_easy_setopt(CURL* curl, CURLoption option,
size_t (*param)(void*, size_t, size_t,
FILE*)) override {
return ::curl_easy_setopt(curl, option, param);
}
CURLcode curl_easy_setopt(CURL* curl, CURLoption option,
size_t (*param)(const void*, size_t, size_t,
void*)) override {
return ::curl_easy_setopt(curl, option, param);
}
CURLcode curl_easy_setopt(CURL* curl, CURLoption option,
int (*param)(void* clientp, curl_off_t dltotal,
curl_off_t dlnow, curl_off_t ultotal,
curl_off_t ulnow)) override {
return ::curl_easy_setopt(curl, option, param);
}
CURLcode curl_easy_perform(CURL* curl) override {
return ::curl_easy_perform(curl);
}
CURLcode curl_easy_getinfo(CURL* curl, CURLINFO info,
uint64* value) override {
return ::curl_easy_getinfo(curl, info, value);
}
CURLcode curl_easy_getinfo(CURL* curl, CURLINFO info,
double* value) override {
return ::curl_easy_getinfo(curl, info, value);
}
void curl_easy_cleanup(CURL* curl) override {
return ::curl_easy_cleanup(curl);
}
char* curl_easy_escape(CURL* curl, const char* str, int length) override {
return ::curl_easy_escape(curl, str, length);
}
curl_slist* curl_slist_append(curl_slist* list, const char* str) override {
return ::curl_slist_append(list, str);
}
void curl_slist_free_all(curl_slist* list) override {
return ::curl_slist_free_all(list);
}
void curl_free(void* p) override { ::curl_free(p); }
};
}
CurlHttpRequest::CurlHttpRequest() : CurlHttpRequest(LibCurlProxy::Load()) {}
CurlHttpRequest::CurlHttpRequest(LibCurl* libcurl, Env* env)
: libcurl_(libcurl), env_(env) {
default_response_buffer_.reserve(CURL_MAX_WRITE_SIZE);
curl_ = libcurl_->curl_easy_init();
CHECK(curl_ != nullptr) << "Couldn't initialize a curl session.";
std::string value = "";
TF_CHECK_OK(ReadStringFromEnvVar("CURL_CA_BUNDLE", "", &value));
if (!value.empty()) {
CHECK_CURL_OK(
libcurl_->curl_easy_setopt(curl_, CURLOPT_CAINFO, value.c_str()));
}
CHECK_CURL_OK(
libcurl_->curl_easy_setopt(curl_, CURLOPT_VERBOSE, kVerboseOutput));
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_USERAGENT, "TSL"));
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_NOSIGNAL, 1L));
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_HTTP_VERSION,
CURL_HTTP_VERSION_1_1));
CHECK_CURL_OK(
libcurl_->curl_easy_setopt(curl_, CURLOPT_NOPROGRESS, uint64{0}));
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_XFERINFODATA, this));
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_XFERINFOFUNCTION,
&CurlHttpRequest::ProgressCallback));
SetResultBuffer(&default_response_buffer_);
}
CurlHttpRequest::~CurlHttpRequest() {
if (curl_headers_) {
libcurl_->curl_slist_free_all(curl_headers_);
}
if (resolve_list_) {
libcurl_->curl_slist_free_all(resolve_list_);
}
if (put_body_) {
if (fclose(put_body_) != 0) {
LOG(ERROR) << "fclose() failed: " << strerror(errno);
}
}
if (curl_) {
libcurl_->curl_easy_cleanup(curl_);
}
}
string CurlHttpRequest::EscapeString(const string& str) {
char* out_char_str = libcurl_->curl_easy_escape(curl_, str.c_str(), 0);
string out_str(out_char_str);
libcurl_->curl_free(out_char_str);
return out_str;
}
void CurlHttpRequest::SetUri(const string& uri) {
CheckNotSent();
is_uri_set_ = true;
uri_ = uri;
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_URL, uri.c_str()));
}
void CurlHttpRequest::SetRange(uint64 start, uint64 end) {
CheckNotSent();
CHECK_CURL_OK(libcurl_->curl_easy_setopt(
curl_, CURLOPT_RANGE, strings::StrCat(start, "-", end).c_str()));
}
void CurlHttpRequest::AddHeader(const string& name, const string& value) {
CheckNotSent();
curl_headers_ = libcurl_->curl_slist_append(
curl_headers_, strings::StrCat(name, ": ", value).c_str());
}
void CurlHttpRequest::AddResolveOverride(const string& hostname, int64_t port,
const string& ip_addr) {
CheckNotSent();
resolve_list_ = libcurl_->curl_slist_append(
resolve_list_,
strings::StrCat(hostname, ":", port, ":", ip_addr).c_str());
}
void CurlHttpRequest::AddAuthBearerHeader(const string& auth_token) {
CheckNotSent();
if (!auth_token.empty()) {
AddHeader("Authorization", strings::StrCat("Bearer ", auth_token));
}
}
void CurlHttpRequest::SetRequestStats(RequestStats* stats) {
CheckNotSent();
CHECK(stats_ == nullptr) << "SetRequestStats already called";
stats_ = stats;
}
void CurlHttpRequest::SetDeleteRequest() {
CheckNotSent();
CheckMethodNotSet();
is_method_set_ = true;
method_ = RequestMethod::kDelete;
CHECK_CURL_OK(
libcurl_->curl_easy_setopt(curl_, CURLOPT_CUSTOMREQUEST, "DELETE"));
}
Status CurlHttpRequest::SetPutFromFile(const string& body_filepath,
size_t offset) {
CheckNotSent();
CheckMethodNotSet();
is_method_set_ = true;
method_ = RequestMethod::kPut;
if (put_body_) {
if (fclose(put_body_) != 0) {
LOG(ERROR) << "fclose() failed: " << strerror(errno);
}
}
put_body_ = fopen(body_filepath.c_str(), "r");
if (!put_body_) {
return errors::InvalidArgument("Couldn't open the specified file: " +
body_filepath);
}
fseek(put_body_, 0, SEEK_END);
const auto size = ftell(put_body_) - offset;
fseek(put_body_, offset, SEEK_SET);
curl_headers_ = libcurl_->curl_slist_append(
curl_headers_, strings::StrCat("Content-Length: ", size).c_str());
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_PUT, 1));
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_READDATA,
reinterpret_cast<void*>(put_body_)));
return OkStatus();
}
void CurlHttpRequest::SetPutEmptyBody() {
CheckNotSent();
CheckMethodNotSet();
is_method_set_ = true;
method_ = RequestMethod::kPut;
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_PUT, 1));
AddHeader("Content-Length", "0");
AddHeader("Transfer-Encoding", "identity");
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_READDATA,
reinterpret_cast<void*>(this)));
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_READFUNCTION,
&CurlHttpRequest::ReadCallback));
}
void CurlHttpRequest::SetPostFromBuffer(const char* buffer, size_t size) {
CheckNotSent();
CheckMethodNotSet();
is_method_set_ = true;
method_ = RequestMethod::kPost;
curl_headers_ = libcurl_->curl_slist_append(
curl_headers_, strings::StrCat("Content-Length: ", size).c_str());
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_POST, 1));
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_READDATA,
reinterpret_cast<void*>(this)));
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_READFUNCTION,
&CurlHttpRequest::ReadCallback));
post_body_buffer_ = StringPiece(buffer, size);
}
void CurlHttpRequest::SetPostEmptyBody() {
CheckNotSent();
CheckMethodNotSet();
is_method_set_ = true;
method_ = RequestMethod::kPost;
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_POST, 1));
AddHeader("Content-Length", "0");
AddHeader("Transfer-Encoding", "identity");
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_READDATA,
reinterpret_cast<void*>(this)));
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_READFUNCTION,
&CurlHttpRequest::ReadCallback));
}
void CurlHttpRequest::SetResultBuffer(std::vector<char>* out_buffer) {
CheckNotSent();
CHECK(out_buffer != nullptr);
out_buffer->clear();
response_buffer_ = out_buffer;
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_WRITEDATA,
reinterpret_cast<void*>(this)));
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_WRITEFUNCTION,
&CurlHttpRequest::WriteCallback));
}
void CurlHttpRequest::SetResultBufferDirect(char* buffer, size_t size) {
CHECK(buffer != nullptr);
CheckNotSent();
direct_response_ = DirectResponseState{buffer, size, 0, 0};
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_WRITEDATA,
reinterpret_cast<void*>(this)));
CHECK_CURL_OK(libcurl_->curl_easy_setopt(
curl_, CURLOPT_WRITEFUNCTION, &CurlHttpRequest::WriteCallbackDirect));
}
bool CurlHttpRequest::IsDirectResponse() const {
return direct_response_.buffer_ != nullptr;
}
size_t CurlHttpRequest::WriteCallbackDirect(const void* ptr, size_t size,
size_t nmemb, void* userdata) {
CHECK(ptr != nullptr);
auto that = reinterpret_cast<CurlHttpRequest*>(userdata);
DirectResponseState* state = &that->direct_response_;
CHECK(state->buffer_ != nullptr);
CHECK(state->bytes_transferred_ <= state->buffer_size_);
size_t curl_bytes_received = size * nmemb;
size_t user_buffer_bytes_available =
state->buffer_size_ - state->bytes_transferred_;
size_t bytes_to_copy =
std::min<size_t>(curl_bytes_received, user_buffer_bytes_available);
memcpy(&state->buffer_[state->bytes_transferred_], ptr, bytes_to_copy);
state->bytes_transferred_ += bytes_to_copy;
state->bytes_received_ += curl_bytes_received;
return bytes_to_copy;
}
size_t CurlHttpRequest::GetResultBufferDirectBytesTransferred() {
CHECK(direct_response_.buffer_ != nullptr);
return direct_response_.bytes_transferred_;
}
void CurlHttpRequest::SetTimeouts(uint32 connection, uint32 inactivity,
uint32 total) {
CheckNotSent();
connect_timeout_secs_ = connection;
inactivity_timeout_secs_ = inactivity;
request_timeout_secs_ = total;
}
size_t CurlHttpRequest::WriteCallback(const void* ptr, size_t size,
size_t nmemb, void* this_object) {
CHECK(ptr);
auto that = reinterpret_cast<CurlHttpRequest*>(this_object);
CHECK(that->response_buffer_);
const size_t bytes_to_copy = size * nmemb;
that->response_buffer_->insert(
that->response_buffer_->end(), reinterpret_cast<const char*>(ptr),
reinterpret_cast<const char*>(ptr) + bytes_to_copy);
return bytes_to_copy;
}
size_t CurlHttpRequest::ReadCallback(void* ptr, size_t size, size_t nmemb,
FILE* this_object) {
CHECK(ptr);
auto that = reinterpret_cast<CurlHttpRequest*>(this_object);
CHECK(that->post_body_read_ <= that->post_body_buffer_.size());
const size_t bytes_to_copy = std::min(
size * nmemb, that->post_body_buffer_.size() - that->post_body_read_);
memcpy(ptr, that->post_body_buffer_.data() + that->post_body_read_,
bytes_to_copy);
that->post_body_read_ += bytes_to_copy;
return bytes_to_copy;
}
size_t CurlHttpRequest::HeaderCallback(const void* ptr, size_t size,
size_t nmemb, void* this_object) {
CHECK(ptr);
auto that = reinterpret_cast<CurlHttpRequest*>(this_object);
StringPiece header(reinterpret_cast<const char*>(ptr), size * nmemb);
StringPiece name, value;
if (strings::Scanner(header)
.ScanEscapedUntil(':')
.StopCapture()
.OneLiteral(": ")
.GetResult(&value, &name)) {
string str_value(value);
absl::StripTrailingAsciiWhitespace(&str_value);
that->response_headers_[string(name)] = str_value;
}
return size * nmemb;
}
Status CurlHttpRequest::Send() {
CheckNotSent();
CHECK(is_uri_set_) << "URI has not been set.";
is_sent_ = true;
if (curl_headers_) {
CHECK_CURL_OK(
libcurl_->curl_easy_setopt(curl_, CURLOPT_HTTPHEADER, curl_headers_));
}
if (resolve_list_) {
CHECK_CURL_OK(
libcurl_->curl_easy_setopt(curl_, CURLOPT_RESOLVE, resolve_list_));
}
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_HEADERDATA,
reinterpret_cast<void*>(this)));
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_HEADERFUNCTION,
&CurlHttpRequest::HeaderCallback));
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_TIMEOUT,
request_timeout_secs_));
CHECK_CURL_OK(libcurl_->curl_easy_setopt(curl_, CURLOPT_CONNECTTIMEOUT,
connect_timeout_secs_));
char error_buffer[CURL_ERROR_SIZE] = {0};
CHECK_CURL_OK(
libcurl_->curl_easy_setopt(curl_, CURLOPT_ERRORBUFFER, error_buffer));
if (stats_ != nullptr) {
stats_->RecordRequest(this, uri_, method_);
}
const CURLcode curl_result = libcurl_->curl_easy_perform(curl_);
TF_RETURN_IF_ERROR(CURLcodeToStatus(curl_result, error_buffer));
double written_size = 0;
CHECK_CURL_OK(libcurl_->curl_easy_getinfo(curl_, CURLINFO_SIZE_DOWNLOAD,
&written_size));
CHECK_CURL_OK(libcurl_->curl_easy_getinfo(curl_, CURLINFO_RESPONSE_CODE,
&response_code_));
auto get_error_message = [this]() -> string {
string error_message = strings::StrCat(
"Error executing an HTTP request: HTTP response code ", response_code_);
StringPiece body = GetResponse();
if (!body.empty()) {
return strings::StrCat(
error_message, " with body '",
body.substr(0, std::min(body.size(), response_to_error_limit_)), "'");
}
return error_message;
};
Status result;
switch (response_code_) {
case 200:
case 201:
case 204:
case 206:
result = OkStatus();
break;
case 416:
response_buffer_->clear();
if (IsDirectResponse()) {
direct_response_.bytes_transferred_ = 0;
}
result = OkStatus();
break;
case 400:
case 406:
case 411:
case 414:
result = errors::InvalidArgument(get_error_message());
break;
case 401:
case 403:
case 407:
result = errors::PermissionDenied(get_error_message());
break;
case 404:
case 410:
result = errors::NotFound(get_error_message());
break;
case 302:
case 303:
case 304:
case 307:
case 412:
case 413:
result = errors::FailedPrecondition(get_error_message());
break;
case 308:
case 409:
case 429:
case 500:
case 502:
case 503:
default:
result = errors::Unavailable(get_error_message());
break;
}
if (!result.ok()) {
response_buffer_->clear();
}
if (stats_ != nullptr) {
stats_->RecordResponse(this, uri_, method_, result);
}
return result;
}
void CurlHttpRequest::CheckMethodNotSet() const {
CHECK(!is_method_set_) << "HTTP method has been already set.";
}
void CurlHttpRequest::CheckNotSent() const {
CHECK(!is_sent_) << "The request has already been sent.";
}
StringPiece CurlHttpRequest::GetResponse() const {
StringPiece response;
if (IsDirectResponse()) {
response = StringPiece(direct_response_.buffer_,
direct_response_.bytes_transferred_);
} else {
response = StringPiece(response_buffer_->data(), response_buffer_->size());
}
return response;
}
string CurlHttpRequest::GetResponseHeader(const string& name) const {
const auto& header = response_headers_.find(name);
return header != response_headers_.end() ? header->second : "";
}
uint64 CurlHttpRequest::GetResponseCode() const { return response_code_; }
int CurlHttpRequest::ProgressCallback(void* this_object, curl_off_t dltotal,
curl_off_t dlnow, curl_off_t ultotal,
curl_off_t ulnow) {
auto that = reinterpret_cast<CurlHttpRequest*>(this_object);
const auto now = that->env_->NowSeconds();
const auto current_progress = dlnow + ulnow;
if (that->last_progress_timestamp_ == 0 ||
current_progress > that->last_progress_bytes_) {
that->last_progress_timestamp_ = now;
that->last_progress_bytes_ = current_progress;
return 0;
}
if (now - that->last_progress_timestamp_ > that->inactivity_timeout_secs_) {
double lookup_time = -1;
const auto lookup_time_status = that->libcurl_->curl_easy_getinfo(
that->curl_, CURLINFO_NAMELOOKUP_TIME, &lookup_time);
double connect_time = -1 | #include "tsl/platform/cloud/curl_http_request.h"
#include <fstream>
#include <string>
#include "absl/status/status.h"
#include "tsl/lib/core/status_test_util.h"
#include "tsl/platform/mem.h"
#include "tsl/platform/path.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace {
const string kTestContent = "random original scratch content";
class FakeEnv : public EnvWrapper {
public:
FakeEnv() : EnvWrapper(Env::Default()) {}
uint64 NowSeconds() const override { return now_; }
uint64 now_ = 10000;
};
class FakeLibCurl : public LibCurl {
public:
FakeLibCurl(const string& response_content, uint64 response_code)
: response_content_(response_content), response_code_(response_code) {}
FakeLibCurl(const string& response_content, uint64 response_code,
std::vector<std::tuple<uint64, curl_off_t>> progress_ticks,
FakeEnv* env)
: response_content_(response_content),
response_code_(response_code),
progress_ticks_(std::move(progress_ticks)),
env_(env) {}
FakeLibCurl(const string& response_content, uint64 response_code,
const std::vector<string>& response_headers)
: response_content_(response_content),
response_code_(response_code),
response_headers_(response_headers) {}
CURL* curl_easy_init() override {
is_initialized_ = true;
return reinterpret_cast<CURL*>(this);
}
CURLcode curl_easy_setopt(CURL* curl, CURLoption option,
uint64 param) override {
switch (option) {
case CURLOPT_POST:
is_post_ = param;
break;
case CURLOPT_PUT:
is_put_ = param;
break;
default:
break;
}
return CURLE_OK;
}
CURLcode curl_easy_setopt(CURL* curl, CURLoption option,
const char* param) override {
return curl_easy_setopt(curl, option,
reinterpret_cast<void*>(const_cast<char*>(param)));
}
CURLcode curl_easy_setopt(CURL* curl, CURLoption option,
void* param) override {
switch (option) {
case CURLOPT_URL:
url_ = reinterpret_cast<char*>(param);
break;
case CURLOPT_RANGE:
range_ = reinterpret_cast<char*>(param);
break;
case CURLOPT_CUSTOMREQUEST:
custom_request_ = reinterpret_cast<char*>(param);
break;
case CURLOPT_HTTPHEADER:
headers_ = reinterpret_cast<std::vector<string>*>(param);
break;
case CURLOPT_ERRORBUFFER:
error_buffer_ = reinterpret_cast<char*>(param);
break;
case CURLOPT_CAINFO:
ca_info_ = reinterpret_cast<char*>(param);
break;
case CURLOPT_WRITEDATA:
write_data_ = reinterpret_cast<FILE*>(param);
break;
case CURLOPT_HEADERDATA:
header_data_ = reinterpret_cast<FILE*>(param);
break;
case CURLOPT_READDATA:
read_data_ = reinterpret_cast<FILE*>(param);
break;
case CURLOPT_XFERINFODATA:
progress_data_ = param;
break;
default:
break;
}
return CURLE_OK;
}
CURLcode curl_easy_setopt(CURL* curl, CURLoption option,
size_t (*param)(void*, size_t, size_t,
FILE*)) override {
read_callback_ = param;
return CURLE_OK;
}
CURLcode curl_easy_setopt(CURL* curl, CURLoption option,
size_t (*param)(const void*, size_t, size_t,
void*)) override {
switch (option) {
case CURLOPT_WRITEFUNCTION:
write_callback_ = param;
break;
case CURLOPT_HEADERFUNCTION:
header_callback_ = param;
break;
default:
break;
}
return CURLE_OK;
}
CURLcode curl_easy_setopt(CURL* curl, CURLoption option,
int (*param)(void* clientp, curl_off_t dltotal,
curl_off_t dlnow, curl_off_t ultotal,
curl_off_t ulnow)) override {
progress_callback_ = param;
return CURLE_OK;
}
CURLcode curl_easy_perform(CURL* curl) override {
if (is_post_ || is_put_) {
char buffer[3];
int bytes_read;
posted_content_ = "";
do {
bytes_read = read_callback_(buffer, 1, sizeof(buffer), read_data_);
posted_content_ =
strings::StrCat(posted_content_, StringPiece(buffer, bytes_read));
} while (bytes_read > 0);
}
if (write_data_ || write_callback_) {
size_t bytes_handled = write_callback_(
response_content_.c_str(), 1, response_content_.size(), write_data_);
if (bytes_handled != response_content_.size()) {
curl_easy_perform_result_ = CURLE_WRITE_ERROR;
}
}
for (const auto& header : response_headers_) {
header_callback_(header.c_str(), 1, header.size(), header_data_);
}
if (error_buffer_) {
strncpy(error_buffer_, curl_easy_perform_error_message_.c_str(),
curl_easy_perform_error_message_.size() + 1);
}
for (const auto& tick : progress_ticks_) {
env_->now_ = std::get<0>(tick);
if (progress_callback_(progress_data_, 0, std::get<1>(tick), 0, 0)) {
return CURLE_ABORTED_BY_CALLBACK;
}
}
return curl_easy_perform_result_;
}
CURLcode curl_easy_getinfo(CURL* curl, CURLINFO info,
uint64* value) override {
switch (info) {
case CURLINFO_RESPONSE_CODE:
*value = response_code_;
break;
default:
break;
}
return CURLE_OK;
}
CURLcode curl_easy_getinfo(CURL* curl, CURLINFO info,
double* value) override {
switch (info) {
case CURLINFO_SIZE_DOWNLOAD:
*value = response_content_.size();
break;
default:
break;
}
return CURLE_OK;
}
void curl_easy_cleanup(CURL* curl) override { is_cleaned_up_ = true; }
curl_slist* curl_slist_append(curl_slist* list, const char* str) override {
std::vector<string>* v = list ? reinterpret_cast<std::vector<string>*>(list)
: new std::vector<string>();
v->push_back(str);
return reinterpret_cast<curl_slist*>(v);
}
char* curl_easy_escape(CURL* curl, const char* str, int length) override {
const string victim = "/";
const string encoded = "%2F";
string temp_str = str;
std::string::size_type n = 0;
while ((n = temp_str.find(victim, n)) != std::string::npos) {
temp_str.replace(n, victim.size(), encoded);
n += encoded.size();
}
char* out_char_str = reinterpret_cast<char*>(
port::Malloc(sizeof(char) * temp_str.size() + 1));
std::copy(temp_str.begin(), temp_str.end(), out_char_str);
out_char_str[temp_str.size()] = '\0';
return out_char_str;
}
void curl_slist_free_all(curl_slist* list) override {
delete reinterpret_cast<std::vector<string>*>(list);
}
void curl_free(void* p) override { port::Free(p); }
string response_content_;
uint64 response_code_;
std::vector<string> response_headers_;
string url_;
string range_;
string custom_request_;
string ca_info_;
char* error_buffer_ = nullptr;
bool is_initialized_ = false;
bool is_cleaned_up_ = false;
std::vector<string>* headers_ = nullptr;
bool is_post_ = false;
bool is_put_ = false;
void* write_data_ = nullptr;
size_t (*write_callback_)(const void* ptr, size_t size, size_t nmemb,
void* userdata) = nullptr;
void* header_data_ = nullptr;
size_t (*header_callback_)(const void* ptr, size_t size, size_t nmemb,
void* userdata) = nullptr;
FILE* read_data_ = nullptr;
size_t (*read_callback_)(void* ptr, size_t size, size_t nmemb,
FILE* userdata) = &fread;
int (*progress_callback_)(void* clientp, curl_off_t dltotal, curl_off_t dlnow,
curl_off_t ultotal, curl_off_t ulnow) = nullptr;
void* progress_data_ = nullptr;
string posted_content_;
CURLcode curl_easy_perform_result_ = CURLE_OK;
string curl_easy_perform_error_message_;
std::vector<std::tuple<uint64, curl_off_t>> progress_ticks_;
FakeEnv* env_ = nullptr;
};
TEST(CurlHttpRequestTest, GetRequest) {
FakeLibCurl libcurl("get response", 200);
CurlHttpRequest http_request(&libcurl);
std::vector<char> scratch;
scratch.insert(scratch.begin(), kTestContent.begin(), kTestContent.end());
scratch.reserve(100);
http_request.SetUri("http:
http_request.AddAuthBearerHeader("fake-bearer");
http_request.SetRange(100, 199);
http_request.SetResultBuffer(&scratch);
TF_EXPECT_OK(http_request.Send());
EXPECT_EQ("get response", string(scratch.begin(), scratch.end()));
EXPECT_TRUE(libcurl.is_initialized_);
EXPECT_EQ("http:
EXPECT_EQ("100-199", libcurl.range_);
EXPECT_EQ("", libcurl.custom_request_);
EXPECT_EQ("", libcurl.ca_info_);
EXPECT_EQ(1, libcurl.headers_->size());
EXPECT_EQ("Authorization: Bearer fake-bearer", (*libcurl.headers_)[0]);
EXPECT_FALSE(libcurl.is_post_);
EXPECT_EQ(200, http_request.GetResponseCode());
}
TEST(CurlHttpRequestTest, GetRequest_Direct) {
FakeLibCurl libcurl("get response", 200);
CurlHttpRequest http_request(&libcurl);
std::vector<char> scratch(100, 0);
http_request.SetUri("http:
http_request.AddAuthBearerHeader("fake-bearer");
http_request.SetRange(100, 199);
http_request.SetResultBufferDirect(scratch.data(), scratch.capacity());
TF_EXPECT_OK(http_request.Send());
string expected_response = "get response";
size_t response_bytes_transferred =
http_request.GetResultBufferDirectBytesTransferred();
EXPECT_EQ(expected_response.size(), response_bytes_transferred);
EXPECT_EQ(
"get response",
string(scratch.begin(), scratch.begin() + response_bytes_transferred));
EXPECT_TRUE(libcurl.is_initialized_);
EXPECT_EQ("http:
EXPECT_EQ("100-199", libcurl.range_);
EXPECT_EQ("", libcurl.custom_request_);
EXPECT_EQ("", libcurl.ca_info_);
EXPECT_EQ(1, libcurl.headers_->size());
EXPECT_EQ("Authorization: Bearer fake-bearer", (*libcurl.headers_)[0]);
EXPECT_FALSE(libcurl.is_post_);
EXPECT_EQ(200, http_request.GetResponseCode());
}
TEST(CurlHttpRequestTest, GetRequest_CustomCaInfoFlag) {
static char set_var[] = "CURL_CA_BUNDLE=test";
putenv(set_var);
FakeLibCurl libcurl("get response", 200);
CurlHttpRequest http_request(&libcurl);
std::vector<char> scratch;
scratch.insert(scratch.begin(), kTestContent.begin(), kTestContent.end());
scratch.reserve(100);
http_request.SetUri("http:
http_request.AddAuthBearerHeader("fake-bearer");
http_request.SetRange(100, 199);
http_request.SetResultBuffer(&scratch);
TF_EXPECT_OK(http_request.Send());
EXPECT_EQ("get response", string(scratch.begin(), scratch.end()));
EXPECT_TRUE(libcurl.is_initialized_);
EXPECT_EQ("http:
EXPECT_EQ("100-199", libcurl.range_);
EXPECT_EQ("", libcurl.custom_request_);
EXPECT_EQ("test", libcurl.ca_info_);
EXPECT_EQ(1, libcurl.headers_->size());
EXPECT_EQ("Authorization: Bearer fake-bearer", (*libcurl.headers_)[0]);
EXPECT_FALSE(libcurl.is_post_);
EXPECT_EQ(200, http_request.GetResponseCode());
}
TEST(CurlHttpRequestTest, GetRequest_Direct_ResponseTooLarge) {
FakeLibCurl libcurl("get response", 200);
CurlHttpRequest http_request(&libcurl);
std::vector<char> scratch(5, 0);
http_request.SetUri("http:
http_request.SetResultBufferDirect(scratch.data(), scratch.size());
const Status& status = http_request.Send();
EXPECT_EQ(error::FAILED_PRECONDITION, status.code());
EXPECT_EQ(
"Error executing an HTTP request: libcurl code 23 meaning "
"'Failed writing received data to disk/application', error details: "
"Received 12 response bytes for a 5-byte buffer",
status.message());
EXPECT_EQ(5, http_request.GetResultBufferDirectBytesTransferred());
EXPECT_EQ("get r", string(scratch.begin(), scratch.begin() + 5));
}
TEST(CurlHttpRequestTest, GetRequest_Direct_RangeOutOfBound) {
FakeLibCurl libcurl("get response", 416);
CurlHttpRequest http_request(&libcurl);
const string initialScratch = "abcde";
std::vector<char> scratch;
scratch.insert(scratch.end(), initialScratch.begin(), initialScratch.end());
http_request.SetUri("http:
http_request.SetRange(0, 4);
http_request.SetResultBufferDirect(scratch.data(), scratch.size());
TF_EXPECT_OK(http_request.Send());
EXPECT_EQ(416, http_request.GetResponseCode());
EXPECT_EQ(0, http_request.GetResultBufferDirectBytesTransferred());
EXPECT_EQ("get r", string(scratch.begin(), scratch.end()));
}
TEST(CurlHttpRequestTest, GetRequest_Empty) {
FakeLibCurl libcurl("", 200);
CurlHttpRequest http_request(&libcurl);
std::vector<char> scratch;
scratch.resize(0);
http_request.SetUri("http:
http_request.AddAuthBearerHeader("fake-bearer");
http_request.SetRange(100, 199);
http_request.SetResultBuffer(&scratch);
TF_EXPECT_OK(http_request.Send());
EXPECT_TRUE(scratch.empty());
EXPECT_TRUE(libcurl.is_initialized_);
EXPECT_EQ("http:
EXPECT_EQ("100-199", libcurl.range_);
EXPECT_EQ("", libcurl.custom_request_);
EXPECT_EQ(1, libcurl.headers_->size());
EXPECT_EQ("Authorization: Bearer fake-bearer", (*libcurl.headers_)[0]);
EXPECT_FALSE(libcurl.is_post_);
EXPECT_EQ(200, http_request.GetResponseCode());
}
TEST(CurlHttpRequestTest, GetRequest_RangeOutOfBound) {
FakeLibCurl libcurl("get response", 416);
CurlHttpRequest http_request(&libcurl);
std::vector<char> scratch;
scratch.insert(scratch.end(), kTestContent.begin(), kTestContent.end());
http_request.SetUri("http:
http_request.AddAuthBearerHeader("fake-bearer");
http_request.SetRange(100, 199);
http_request.SetResultBuffer(&scratch);
TF_EXPECT_OK(http_request.Send());
EXPECT_TRUE(scratch.empty());
EXPECT_EQ(416, http_request.GetResponseCode());
}
TEST(CurlHttpRequestTest, GetRequest_503) {
FakeLibCurl libcurl("get response", 503);
CurlHttpRequest http_request(&libcurl);
std::vector<char> scratch;
scratch.insert(scratch.end(), kTestContent.begin(), kTestContent.end());
http_request.SetUri("http:
http_request.SetResultBuffer(&scratch);
const auto& status = http_request.Send();
EXPECT_EQ(error::UNAVAILABLE, status.code());
EXPECT_EQ(
"Error executing an HTTP request: HTTP response code 503 with body "
"'get response'",
status.message());
}
TEST(CurlHttpRequestTest, GetRequest_HttpCode0) {
FakeLibCurl libcurl("get response", 0);
libcurl.curl_easy_perform_result_ = CURLE_OPERATION_TIMEDOUT;
libcurl.curl_easy_perform_error_message_ = "Operation timed out";
CurlHttpRequest http_request(&libcurl);
std::vector<char> scratch;
scratch.insert(scratch.end(), kTestContent.begin(), kTestContent.end());
http_request.SetUri("http:
const auto& status = http_request.Send();
EXPECT_EQ(error::UNAVAILABLE, status.code());
EXPECT_EQ(
"Error executing an HTTP request: libcurl code 28 meaning "
"'Timeout was reached', error details: Operation timed out",
status.message());
EXPECT_EQ(0, http_request.GetResponseCode());
}
TEST(CurlHttpRequestTest, GetRequest_CouldntResolveHost) {
FakeLibCurl libcurl("get response", 0);
libcurl.curl_easy_perform_result_ = CURLE_COULDNT_RESOLVE_HOST;
libcurl.curl_easy_perform_error_message_ =
"Could not resolve host 'metadata'";
CurlHttpRequest http_request(&libcurl);
std::vector<char> scratch;
scratch.insert(scratch.end(), kTestContent.begin(), kTestContent.end());
http_request.SetUri("http:
const auto& status = http_request.Send();
EXPECT_EQ(error::FAILED_PRECONDITION, status.code());
EXPECT_EQ(
"Error executing an HTTP request: libcurl code 6 meaning "
"'Couldn't resolve host name', error details: Could not resolve host "
"'metadata'",
status.message());
EXPECT_EQ(0, http_request.GetResponseCode());
}
TEST(CurlHttpRequestTest, GetRequest_SslBadCertfile) {
FakeLibCurl libcurl("get response", 0);
libcurl.curl_easy_perform_result_ = CURLE_SSL_CACERT_BADFILE;
libcurl.curl_easy_perform_error_message_ =
"error setting certificate verify locations:";
CurlHttpRequest http_request(&libcurl);
std::vector<char> scratch;
scratch.insert(scratch.end(), kTestContent.begin(), kTestContent.end());
http_request.SetUri("http:
const auto& status = http_request.Send();
EXPECT_EQ(error::FAILED_PRECONDITION, status.code());
EXPECT_EQ(
"Error executing an HTTP request: libcurl code 77 meaning "
"'Problem with the SSL CA cert (path? access rights?)', error details: "
"error setting certificate verify locations:",
status.message());
EXPECT_EQ(0, http_request.GetResponseCode());
}
TEST(CurlHttpRequestTest, ResponseHeaders) {
FakeLibCurl libcurl(
"get response", 200,
{"Location: abcd", "Content-Type: text", "unparsable header"});
CurlHttpRequest http_request(&libcurl);
http_request.SetUri("http:
TF_EXPECT_OK(http_request.Send());
EXPECT_EQ("abcd", http_request.GetResponseHeader("Location"));
EXPECT_EQ("text", http_request.GetResponseHeader("Content-Type"));
EXPECT_EQ("", http_request.GetResponseHeader("Not-Seen-Header"));
}
TEST(CurlHttpRequestTest, PutRequest_WithBody_FromFile) {
FakeLibCurl libcurl("", 200);
CurlHttpRequest http_request(&libcurl);
auto content_filename = io::JoinPath(testing::TmpDir(), "content");
std::ofstream content(content_filename, std::ofstream::binary);
content << "post body content";
content.close();
http_request.SetUri("http:
http_request.AddAuthBearerHeader("fake-bearer");
TF_EXPECT_OK(http_request.SetPutFromFile(content_filename, 0));
TF_EXPECT_OK(http_request.Send());
EXPECT_TRUE(libcurl.is_initialized_);
EXPECT_EQ("http:
EXPECT_EQ("", libcurl.custom_request_);
EXPECT_EQ(2, libcurl.headers_->size());
EXPECT_EQ("Authorization: Bearer fake-bearer", (*libcurl.headers_)[0]);
EXPECT_EQ("Content-Length: 17", (*libcurl.headers_)[1]);
EXPECT_TRUE(libcurl.is_put_);
EXPECT_EQ("post body content", libcurl.posted_content_);
std::remove(content_filename.c_str());
}
TEST(CurlHttpRequestTest, PutRequest_WithBody_FromFile_NonZeroOffset) {
FakeLibCurl libcurl("", 200);
CurlHttpRequest http_request(&libcurl);
auto content_filename = io::JoinPath(testing::TmpDir(), "content");
std::ofstream content(content_filename, std::ofstream::binary);
content << "post body content";
content.close();
http_request.SetUri("http:
http_request.AddAuthBearerHeader("fake-bearer");
TF_EXPECT_OK(http_request.SetPutFromFile(content_filename, 7));
TF_EXPECT_OK(http_request.Send());
EXPECT_EQ("dy content", libcurl.posted_content_);
std::remove(content_filename.c_str());
}
TEST(CurlHttpRequestTest, PutRequest_WithoutBody) {
FakeLibCurl libcurl("", 200);
CurlHttpRequest http_request(&libcurl);
http_request.SetUri("http:
http_request.AddAuthBearerHeader("fake-bearer");
http_request.SetPutEmptyBody();
TF_EXPECT_OK(http_request.Send());
EXPECT_TRUE(libcurl.is_initialized_);
EXPECT_EQ("http:
EXPECT_EQ("", libcurl.custom_request_);
EXPECT_EQ(3, libcurl.headers_->size());
EXPECT_EQ("Authorization: Bearer fake-bearer", (*libcurl.headers_)[0]);
EXPECT_EQ("Content-Length: 0", (*libcurl.headers_)[1]);
EXPECT_EQ("Transfer-Encoding: identity", (*libcurl.headers_)[2]);
EXPECT_TRUE(libcurl.is_put_);
EXPECT_EQ("", libcurl.posted_content_);
}
TEST(CurlHttpRequestTest, PostRequest_WithBody_FromMemory) {
FakeLibCurl libcurl("", 200);
CurlHttpRequest http_request(&libcurl);
string content = "post body content";
http_request.SetUri("http:
http_request.AddAuthBearerHeader("fake-bearer");
http_request.SetPostFromBuffer(content.c_str(), content.size());
TF_EXPECT_OK(http_request.Send());
EXPECT_TRUE(libcurl.is_initialized_);
EXPECT_EQ("http:
EXPECT_EQ("", libcurl.custom_request_);
EXPECT_EQ(2, libcurl.headers_->size());
EXPECT_EQ("Authorization: Bearer fake-bearer", (*libcurl.headers_)[0]);
EXPECT_EQ("Content-Length: 17", (*libcurl.headers_)[1]);
EXPECT_TRUE(libcurl.is_post_);
EXPECT_EQ("post body content", libcurl.posted_content_);
}
TEST(CurlHttpRequestTest, PostRequest_WithoutBody) {
FakeLibCurl libcurl("", 200);
CurlHttpRequest http_request(&libcurl);
http_request.SetUri("http:
http_request.AddAuthBearerHeader("fake-bearer");
http_request.SetPostEmptyBody();
TF_EXPECT_OK(http_request.Send());
EXPECT_TRUE(libcurl.is_initialized_);
EXPECT_EQ("http:
EXPECT_EQ("", libcurl.custom_request_);
EXPECT_EQ(3, libcurl.headers_->size());
EXPECT_EQ("Authorization: Bearer fake-bearer", (*libcurl.headers_)[0]);
EXPECT_EQ("Content-Length: 0", (*libcurl.headers_)[1]);
EXPECT_EQ("Transfer-Encoding: identity", (*libcurl.headers_)[2]);
EXPECT_TRUE(libcurl.is_post_);
EXPECT_EQ("", libcurl.posted_content_);
}
TEST(CurlHttpRequestTest, DeleteRequest) {
FakeLibCurl libcurl("", 200);
CurlHttpRequest http_request(&libcurl);
http_request.SetUri("http:
http_request.AddAuthBearerHeader("fake-bearer");
http_request.SetDeleteRequest();
TF_EXPECT_OK(http_request.Send());
EXPECT_TRUE(libcurl.is_initialized_);
EXPECT_EQ("http:
EXPECT_EQ("DELETE", libcurl.custom_request_);
EXPECT_EQ(1, libcurl.headers_->size());
EXPECT_EQ("Authorization: Bearer fake-bearer", (*libcurl.headers_)[0]);
EXPECT_FALSE(libcurl.is_post_);
}
TEST(CurlHttpRequestTest, WrongSequenceOfCalls_NoUri) {
FakeLibCurl libcurl("", 200);
CurlHttpRequest http_request(&libcurl);
ASSERT_DEATH((void)http_request.Send(), "URI has not been set");
}
TEST(CurlHttpRequestTest, WrongSequenceOfCalls_TwoSends) {
FakeLibCurl libcurl("", 200);
CurlHttpRequest http_request(&libcurl);
http_request.SetUri("http:
TF_EXPECT_OK(http_request.Send());
ASSERT_DEATH((void)http_request.Send(), "The request has already been sent");
}
TEST(CurlHttpRequestTest, WrongSequenceOfCalls_ReusingAfterSend) {
FakeLibCurl libcurl("", 200);
CurlHttpRequest http_request(&libcurl);
http_request.SetUri("http:
TF_EXPECT_OK(http_request.Send());
ASSERT_DEATH(http_request.SetUri("http:
"The request has already been sent");
}
TEST(CurlHttpRequestTest, WrongSequenceOfCalls_SettingMethodTwice) {
FakeLibCurl libcurl("", 200);
CurlHttpRequest http_request(&libcurl);
http_request.SetDeleteRequest();
ASSERT_DEATH(http_request.SetPostEmptyBody(),
"HTTP method has been already set");
}
TEST(CurlHttpRequestTest, EscapeString) {
FakeLibCurl libcurl("get response", 200);
CurlHttpRequest http_request(&libcurl);
const string test_string = "a/b/c";
EXPECT_EQ("a%2Fb%2Fc", http_request.EscapeString(test_string));
}
TEST(CurlHttpRequestTest, ErrorReturnsNoResponse) {
FakeLibCurl libcurl("get response", 500);
CurlHttpRequest http_request(&libcurl);
std::vector<char> scratch;
scratch.insert(scratch.begin(), kTestContent.begin(), kTestContent.end());
scratch.reserve(100);
http_request.SetUri("http:
http_request.AddAuthBearerHeader("fake-bearer");
http_request.SetRange(100, 199);
http_request.SetResultBuffer(&scratch);
EXPECT_EQ(error::UNAVAILABLE, http_request.Send().code());
EXPECT_EQ("", string(scratch.begin(), scratch.end()));
}
TEST(CurlHttpRequestTest, ProgressIsOk) {
FakeEnv env;
FakeLibCurl libcurl(
"test", 200,
{
std::make_tuple(100, 0) ,
std::make_tuple(110, 0) ,
std::make_tuple(200, 100)
},
&env);
CurlHttpRequest http_request(&libcurl, &env);
http_request.SetUri("http:
TF_EXPECT_OK(http_request.Send());
}
TEST(CurlHttpRequestTest, ProgressIsStuck) {
FakeEnv env;
FakeLibCurl libcurl(
"test", 200,
{
std::make_tuple(100, 10) ,
std::make_tuple(130, 10) ,
std::make_tuple(170, 10)
},
&env);
CurlHttpRequest http_request(&libcurl, &env);
http_request.SetUri("http:
auto status = http_request.Send();
EXPECT_EQ(error::UNAVAILABLE, status.code());
EXPECT_EQ(
"Error executing an HTTP request: libcurl code 42 meaning 'Operation "
"was aborted by an application callback', error details: (none)",
status.message());
}
class TestStats : public HttpRequest::RequestStats {
public:
~TestStats() override = default;
void RecordRequest(const HttpRequest* request, const string& uri,
HttpRequest::RequestMethod method) override {
has_recorded_request_ = true;
record_request_request_ = request;
record_request_uri_ = uri;
record_request_method_ = method;
}
void RecordResponse(const HttpRequest* request, const string& uri,
HttpRequest::RequestMethod method,
const Status& result) override {
has_recorded_response_ = true;
record_response_request_ = request;
record_response_uri_ = uri;
record_response_method_ = method;
record_response_result_ = result;
}
const HttpRequest* record_request_request_ = nullptr;
string record_request_uri_ = "http:
HttpRequest::RequestMethod record_request_method_ =
HttpRequest::RequestMethod::kGet;
const HttpRequest* record_response_request_ = nullptr;
string record_response_uri_ = "http:
HttpRequest::RequestMethod record_response_method_ =
HttpRequest::RequestMethod::kGet;
Status record_response_result_;
bool has_recorded_request_ = false;
bool has_recorded_response_ = false;
};
class StatsTestFakeLibCurl : public FakeLibCurl {
public:
StatsTestFakeLibCurl(TestStats* stats, const string& response_content,
uint64 response_code)
: FakeLibCurl(response_content, response_code), stats_(stats) {}
CURLcode curl_easy_perform(CURL* curl) override {
CHECK(!performed_request_);
performed_request_ = true;
stats_had_recorded_request_ = stats_->has_recorded_request_;
stats_had_recorded_response_ = stats_->has_recorded_response_;
return FakeLibCurl::curl_easy_perform(curl);
};
TestStats* stats_;
bool performed_request_ = false;
bool stats_had_recorded_request_;
bool stats_had_recorded_response_;
};
TEST(CurlHttpRequestTest, StatsGetSuccessful) {
TestStats stats;
StatsTestFakeLibCurl libcurl(&stats, "get response", 200);
CurlHttpRequest http_request(&libcurl);
std::vector<char> scratch;
scratch.insert(scratch.begin(), kTestContent.begin(), kTestContent.end());
scratch.reserve(100);
http_request.SetRequestStats(&stats);
http_request.SetUri("http:
http_request.AddAuthBearerHeader("fake-bearer");
http_request.SetRange(100, 199);
http_request.SetResultBuffer(&scratch);
TF_EXPECT_OK(http_request.Send());
EXPECT_EQ("get response", string(scratch.begin(), scratch.end()));
ASSERT_TRUE(stats.has_recorded_request_);
EXPECT_EQ(&http_request, stats.record_request_request_);
EXPECT_EQ("http:
EXPECT_EQ(HttpRequest::RequestMethod::kGet, stats.record_request_method_);
ASSERT_TRUE(stats.has_recorded_response_);
EXPECT_EQ(&http_request, stats.record_response_request_);
EXPECT_EQ("http:
EXPECT_EQ(HttpRequest::RequestMethod::kGet, stats.record_response_method_);
TF_EXPECT_OK(stats.record_response_result_);
EXPECT_TRUE(libcurl.performed_request_);
EXPECT_TRUE(libcurl.stats_had_recorded_request_);
EXPECT_FALSE(libcurl.stats_had_recorded_response_);
}
TEST(CurlHttpRequestTest, StatsGetNotFound) {
TestStats stats;
StatsTestFakeLibCurl libcurl(&stats, "get other response", 404);
CurlHttpRequest http_request(&libcurl);
std::vector<char> scratch;
scratch.insert(scratch.begin(), kTestContent.begin(), kTestContent.end());
scratch.reserve(100);
http_request.SetRequestStats(&stats);
http_request.SetUri("http:
http_request.AddAuthBearerHeader("fake-bearer");
http_request.SetRange(100, 199);
http_request.SetResultBuffer(&scratch);
Status s = http_request.Send();
ASSERT_TRUE(stats.has_recorded_request_);
EXPECT_EQ(&http_request, stats.record_request_request_);
EXPECT_EQ("http:
EXPECT_EQ(HttpRequest::RequestMethod::kGet, stats.record_request_method_);
ASSERT_TRUE(stats.has_recorded_response_);
EXPECT_EQ(&http_request, stats.record_response_request_);
EXPECT_EQ("http:
EXPECT_EQ(HttpRequest::RequestMethod::kGet, stats.record_response_method_);
EXPECT_TRUE(absl::IsNotFound(stats.record_response_result_));
EXPECT_EQ(s, stats.record_response_result_);
EXPECT_TRUE(libcurl.performed_request_);
EXPECT_TRUE(libcurl.stats_had_recorded_request_);
EXPECT_FALSE(libcurl.stats_had_recorded_response_);
}
TEST(CurlHttpRequestTest, StatsPost) {
TestStats stats;
FakeLibCurl libcurl("", 200);
CurlHttpRequest http_request(&libcurl);
http_request.SetRequestStats(&stats);
string content = "post body content";
http_request.SetUri("http:
http_request.SetPostFromBuffer(content.c_str(), content.size());
TF_EXPECT_OK(http_request.Send());
ASSERT_TRUE(stats.has_recorded_request_);
EXPECT_EQ(&http_request, stats.record_request_request_);
EXPECT_EQ("http:
EXPECT_EQ(HttpR |
2,607 | cpp | google/tsl | ram_file_block_cache | tsl/platform/cloud/ram_file_block_cache.cc | tsl/platform/cloud/ram_file_block_cache_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_CLOUD_RAM_FILE_BLOCK_CACHE_H_
#define TENSORFLOW_TSL_PLATFORM_CLOUD_RAM_FILE_BLOCK_CACHE_H_
#include <functional>
#include <list>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include "tsl/platform/cloud/file_block_cache.h"
#include "tsl/platform/env.h"
#include "tsl/platform/mutex.h"
#include "tsl/platform/notification.h"
#include "tsl/platform/status.h"
#include "tsl/platform/stringpiece.h"
#include "tsl/platform/thread_annotations.h"
#include "tsl/platform/types.h"
namespace tsl {
class RamFileBlockCache : public FileBlockCache {
public:
typedef std::function<Status(const string& filename, size_t offset,
size_t buffer_size, char* buffer,
size_t* bytes_transferred)>
BlockFetcher;
RamFileBlockCache(size_t block_size, size_t max_bytes, uint64 max_staleness,
BlockFetcher block_fetcher, Env* env = Env::Default())
: block_size_(block_size),
max_bytes_(max_bytes),
max_staleness_(max_staleness),
block_fetcher_(block_fetcher),
env_(env) {
if (max_staleness_ > 0) {
pruning_thread_.reset(env_->StartThread(ThreadOptions(), "TF_prune_FBC",
[this] { Prune(); }));
}
VLOG(1) << "GCS file block cache is "
<< (IsCacheEnabled() ? "enabled" : "disabled");
}
~RamFileBlockCache() override {
if (pruning_thread_) {
stop_pruning_thread_.Notify();
pruning_thread_.reset();
}
}
Status Read(const string& filename, size_t offset, size_t n, char* buffer,
size_t* bytes_transferred) override;
bool ValidateAndUpdateFileSignature(const string& filename,
int64_t file_signature) override
TF_LOCKS_EXCLUDED(mu_);
void RemoveFile(const string& filename) override TF_LOCKS_EXCLUDED(mu_);
void Flush() override TF_LOCKS_EXCLUDED(mu_);
size_t block_size() const override { return block_size_; }
size_t max_bytes() const override { return max_bytes_; }
uint64 max_staleness() const override { return max_staleness_; }
size_t CacheSize() const override TF_LOCKS_EXCLUDED(mu_);
bool IsCacheEnabled() const override {
return block_size_ > 0 && max_bytes_ > 0;
}
private:
const size_t block_size_;
const size_t max_bytes_;
const uint64 max_staleness_;
const BlockFetcher block_fetcher_;
Env* const env_;
typedef std::pair<string, size_t> Key;
enum class FetchState {
CREATED,
FETCHING,
FINISHED,
ERROR,
};
struct Block {
std::vector<char> data;
std::list<Key>::iterator lru_iterator;
std::list<Key>::iterator lra_iterator;
uint64 timestamp;
mutex mu;
FetchState state TF_GUARDED_BY(mu) = FetchState::CREATED;
condition_variable cond_var;
};
typedef std::map<Key, std::shared_ptr<Block>> BlockMap;
void Prune() TF_LOCKS_EXCLUDED(mu_);
bool BlockNotStale(const std::shared_ptr<Block>& block)
TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
std::shared_ptr<Block> Lookup(const Key& key) TF_LOCKS_EXCLUDED(mu_);
Status MaybeFetch(const Key& key, const std::shared_ptr<Block>& block)
TF_LOCKS_EXCLUDED(mu_);
void Trim() TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
Status UpdateLRU(const Key& key, const std::shared_ptr<Block>& block)
TF_LOCKS_EXCLUDED(mu_);
void RemoveFile_Locked(const string& filename)
TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
void RemoveBlock(BlockMap::iterator entry) TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
std::unique_ptr<Thread> pruning_thread_;
Notification stop_pruning_thread_;
mutable mutex mu_;
BlockMap block_map_ TF_GUARDED_BY(mu_);
std::list<Key> lru_list_ TF_GUARDED_BY(mu_);
std::list<Key> lra_list_ TF_GUARDED_BY(mu_);
size_t cache_size_ TF_GUARDED_BY(mu_) = 0;
std::map<string, int64_t> file_signature_map_ TF_GUARDED_BY(mu_);
};
}
#endif
#include "tsl/platform/cloud/ram_file_block_cache.h"
#include <cstring>
#include <memory>
#include "absl/cleanup/cleanup.h"
#include "tsl/platform/env.h"
namespace tsl {
bool RamFileBlockCache::BlockNotStale(const std::shared_ptr<Block>& block) {
mutex_lock l(block->mu);
if (block->state != FetchState::FINISHED) {
return true;
}
if (max_staleness_ == 0) return true;
return env_->NowSeconds() - block->timestamp <= max_staleness_;
}
std::shared_ptr<RamFileBlockCache::Block> RamFileBlockCache::Lookup(
const Key& key) {
mutex_lock lock(mu_);
auto entry = block_map_.find(key);
if (entry != block_map_.end()) {
if (BlockNotStale(entry->second)) {
if (cache_stats_ != nullptr) {
cache_stats_->RecordCacheHitBlockSize(entry->second->data.size());
}
return entry->second;
} else {
RemoveFile_Locked(key.first);
}
}
auto new_entry = std::make_shared<Block>();
lru_list_.push_front(key);
lra_list_.push_front(key);
new_entry->lru_iterator = lru_list_.begin();
new_entry->lra_iterator = lra_list_.begin();
new_entry->timestamp = env_->NowSeconds();
block_map_.emplace(std::make_pair(key, new_entry));
return new_entry;
}
void RamFileBlockCache::Trim() {
while (!lru_list_.empty() && cache_size_ > max_bytes_) {
RemoveBlock(block_map_.find(lru_list_.back()));
}
}
Status RamFileBlockCache::UpdateLRU(const Key& key,
const std::shared_ptr<Block>& block) {
mutex_lock lock(mu_);
if (block->timestamp == 0) {
return OkStatus();
}
if (block->lru_iterator != lru_list_.begin()) {
lru_list_.erase(block->lru_iterator);
lru_list_.push_front(key);
block->lru_iterator = lru_list_.begin();
}
if (block->data.size() < block_size_) {
Key fmax = std::make_pair(key.first, std::numeric_limits<size_t>::max());
auto fcmp = block_map_.upper_bound(fmax);
if (fcmp != block_map_.begin() && key < (--fcmp)->first) {
return errors::Internal("Block cache contents are inconsistent.");
}
}
Trim();
return OkStatus();
}
Status RamFileBlockCache::MaybeFetch(const Key& key,
const std::shared_ptr<Block>& block) {
bool downloaded_block = false;
auto reconcile_state =
absl::MakeCleanup([this, &downloaded_block, &key, &block] {
if (downloaded_block) {
mutex_lock l(mu_);
if (block->timestamp != 0) {
cache_size_ += block->data.capacity();
lra_list_.erase(block->lra_iterator);
lra_list_.push_front(key);
block->lra_iterator = lra_list_.begin();
block->timestamp = env_->NowSeconds();
}
}
});
mutex_lock l(block->mu);
Status status = OkStatus();
while (true) {
switch (block->state) {
case FetchState::ERROR:
TF_FALLTHROUGH_INTENDED;
case FetchState::CREATED:
block->state = FetchState::FETCHING;
block->mu.unlock();
block->data.clear();
block->data.resize(block_size_, 0);
size_t bytes_transferred;
status.Update(block_fetcher_(key.first, key.second, block_size_,
block->data.data(), &bytes_transferred));
if (cache_stats_ != nullptr) {
cache_stats_->RecordCacheMissBlockSize(bytes_transferred);
}
block->mu.lock();
if (status.ok()) {
block->data.resize(bytes_transferred, 0);
std::vector<char>(block->data).swap(block->data);
downloaded_block = true;
block->state = FetchState::FINISHED;
} else {
block->state = FetchState::ERROR;
}
block->cond_var.notify_all();
return status;
case FetchState::FETCHING:
block->cond_var.wait_for(l, std::chrono::seconds(60));
if (block->state == FetchState::FINISHED) {
return OkStatus();
}
break;
case FetchState::FINISHED:
return OkStatus();
}
}
return errors::Internal(
"Control flow should never reach the end of RamFileBlockCache::Fetch.");
}
Status RamFileBlockCache::Read(const string& filename, size_t offset, size_t n,
char* buffer, size_t* bytes_transferred) {
*bytes_transferred = 0;
if (n == 0) {
return OkStatus();
}
if (!IsCacheEnabled() || (n > max_bytes_)) {
return block_fetcher_(filename, offset, n, buffer, bytes_transferred);
}
size_t start = block_size_ * (offset / block_size_);
size_t finish = block_size_ * ((offset + n) / block_size_);
if (finish < offset + n) {
finish += block_size_;
}
size_t total_bytes_transferred = 0;
for (size_t pos = start; pos < finish; pos += block_size_) {
Key key = std::make_pair(filename, pos);
std::shared_ptr<Block> block = Lookup(key);
DCHECK(block) << "No block for key " << key.first << "@" << key.second;
TF_RETURN_IF_ERROR(MaybeFetch(key, block));
TF_RETURN_IF_ERROR(UpdateLRU(key, block));
const auto& data = block->data;
if (offset >= pos + data.size()) {
*bytes_transferred = total_bytes_transferred;
return errors::OutOfRange("EOF at offset ", offset, " in file ", filename,
" at position ", pos, "with data size ",
data.size());
}
auto begin = data.begin();
if (offset > pos) {
begin += offset - pos;
}
auto end = data.end();
if (pos + data.size() > offset + n) {
end -= (pos + data.size()) - (offset + n);
}
if (begin < end) {
size_t bytes_to_copy = end - begin;
memcpy(&buffer[total_bytes_transferred], &*begin, bytes_to_copy);
total_bytes_transferred += bytes_to_copy;
}
if (data.size() < block_size_) {
break;
}
}
*bytes_transferred = total_bytes_transferred;
return OkStatus();
}
bool RamFileBlockCache::ValidateAndUpdateFileSignature(const string& filename,
int64_t file_signature) {
mutex_lock lock(mu_);
auto it = file_signature_map_.find(filename);
if (it != file_signature_map_.end()) {
if (it->second == file_signature) {
return true;
}
RemoveFile_Locked(filename);
it->second = file_signature;
return false;
}
file_signature_map_[filename] = file_signature;
return true;
}
size_t RamFileBlockCache::CacheSize() const {
mutex_lock lock(mu_);
return cache_size_;
}
void RamFileBlockCache::Prune() {
while (!WaitForNotificationWithTimeout(&stop_pruning_thread_, 1000000)) {
mutex_lock lock(mu_);
uint64 now = env_->NowSeconds();
while (!lra_list_.empty()) {
auto it = block_map_.find(lra_list_.back());
if (now - it->second->timestamp <= max_staleness_) {
break;
}
RemoveFile_Locked(std::string(it->first.first));
}
}
}
void RamFileBlockCache::Flush() {
mutex_lock lock(mu_);
block_map_.clear();
lru_list_.clear();
lra_list_.clear();
cache_size_ = 0;
}
void RamFileBlockCache::RemoveFile(const string& filename) {
mutex_lock lock(mu_);
RemoveFile_Locked(filename);
}
void RamFileBlockCache::RemoveFile_Locked(const string& filename) {
Key begin = std::make_pair(filename, 0);
auto it = block_map_.lower_bound(begin);
while (it != block_map_.end() && it->first.first == filename) {
auto next = std::next(it);
RemoveBlock(it);
it = next;
}
}
void RamFileBlockCache::RemoveBlock(BlockMap::iterator entry) {
entry->second->timestamp = 0;
lru_list_.erase(entry->second->lru_iterator);
lra_list_.erase(entry->second->lra_iterator);
cache_size_ -= entry->second->data.capacity();
block_map_.erase(entry);
}
} | #include "tsl/platform/cloud/ram_file_block_cache.h"
#include <cstring>
#include "tsl/lib/core/status_test_util.h"
#include "tsl/platform/blocking_counter.h"
#include "tsl/platform/cloud/now_seconds_env.h"
#include "tsl/platform/env.h"
#include "tsl/platform/notification.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace {
Status ReadCache(RamFileBlockCache* cache, const string& filename,
size_t offset, size_t n, std::vector<char>* out) {
out->clear();
out->resize(n, 0);
size_t bytes_transferred = 0;
Status status =
cache->Read(filename, offset, n, out->data(), &bytes_transferred);
EXPECT_LE(bytes_transferred, n);
out->resize(bytes_transferred, n);
return status;
}
TEST(RamFileBlockCacheTest, IsCacheEnabled) {
auto fetcher = [](const string& filename, size_t offset, size_t n,
char* buffer, size_t* bytes_transferred) {
return OkStatus();
};
RamFileBlockCache cache1(0, 0, 0, fetcher);
RamFileBlockCache cache2(16, 0, 0, fetcher);
RamFileBlockCache cache3(0, 32, 0, fetcher);
RamFileBlockCache cache4(16, 32, 0, fetcher);
EXPECT_FALSE(cache1.IsCacheEnabled());
EXPECT_FALSE(cache2.IsCacheEnabled());
EXPECT_FALSE(cache3.IsCacheEnabled());
EXPECT_TRUE(cache4.IsCacheEnabled());
}
TEST(RamFileBlockCacheTest, ValidateAndUpdateFileSignature) {
int calls = 0;
auto fetcher = [&calls](const string& filename, size_t offset, size_t n,
char* buffer, size_t* bytes_transferred) {
calls++;
memset(buffer, 'x', n);
*bytes_transferred = n;
return OkStatus();
};
string filename = "file";
RamFileBlockCache cache(16, 32, 0, fetcher);
std::vector<char> out;
EXPECT_TRUE(cache.ValidateAndUpdateFileSignature(filename, 123));
TF_EXPECT_OK(ReadCache(&cache, filename, 0, 16, &out));
EXPECT_EQ(calls, 1);
EXPECT_TRUE(cache.ValidateAndUpdateFileSignature(filename, 123));
TF_EXPECT_OK(ReadCache(&cache, filename, 0, 16, &out));
EXPECT_EQ(calls, 1);
EXPECT_FALSE(cache.ValidateAndUpdateFileSignature(filename, 321));
TF_EXPECT_OK(ReadCache(&cache, filename, 0, 16, &out));
EXPECT_EQ(calls, 2);
}
TEST(RamFileBlockCacheTest, PassThrough) {
const string want_filename = "foo/bar";
const size_t want_offset = 42;
const size_t want_n = 1024;
int calls = 0;
auto fetcher = [&calls, want_filename, want_offset, want_n](
const string& got_filename, size_t got_offset,
size_t got_n, char* buffer, size_t* bytes_transferred) {
EXPECT_EQ(got_filename, want_filename);
EXPECT_EQ(got_offset, want_offset);
EXPECT_EQ(got_n, want_n);
calls++;
memset(buffer, 'x', got_n);
*bytes_transferred = got_n;
return OkStatus();
};
RamFileBlockCache cache1(1, 0, 0, fetcher);
RamFileBlockCache cache2(0, 1, 0, fetcher);
RamFileBlockCache cache3(0, 0, 0, fetcher);
RamFileBlockCache cache4(1000, 1000, 0, fetcher);
std::vector<char> out;
TF_EXPECT_OK(ReadCache(&cache1, want_filename, want_offset, want_n, &out));
EXPECT_EQ(calls, 1);
TF_EXPECT_OK(ReadCache(&cache2, want_filename, want_offset, want_n, &out));
EXPECT_EQ(calls, 2);
TF_EXPECT_OK(ReadCache(&cache3, want_filename, want_offset, want_n, &out));
EXPECT_EQ(calls, 3);
TF_EXPECT_OK(ReadCache(&cache4, want_filename, want_offset, want_n, &out));
EXPECT_EQ(calls, 4);
}
TEST(RamFileBlockCacheTest, BlockAlignment) {
const size_t size = 256;
std::vector<char> buf;
for (int i = 0; i < size; i++) {
buf.push_back(i);
}
auto fetcher = [&buf](const string& filename, size_t offset, size_t n,
char* buffer, size_t* bytes_transferred) {
if (offset < buf.size()) {
size_t bytes_to_copy = std::min<size_t>(buf.size() - offset, n);
memcpy(buffer, buf.data() + offset, bytes_to_copy);
*bytes_transferred = bytes_to_copy;
} else {
*bytes_transferred = 0;
}
return OkStatus();
};
for (size_t block_size = 2; block_size <= 4; block_size++) {
RamFileBlockCache cache(block_size, block_size, 0, fetcher);
for (size_t offset = 0; offset < 10; offset++) {
for (size_t n = block_size - 2; n <= block_size + 2; n++) {
std::vector<char> got;
TF_EXPECT_OK(ReadCache(&cache, "", offset, n, &got));
if (offset + n <= size) {
EXPECT_EQ(got.size(), n) << "block size = " << block_size
<< ", offset = " << offset << ", n = " << n;
} else {
EXPECT_EQ(got.size(), size - offset)
<< "block size = " << block_size << ", offset = " << offset
<< ", n = " << n;
}
std::vector<char>::const_iterator begin = buf.begin() + offset;
std::vector<char>::const_iterator end =
offset + n > buf.size() ? buf.end() : begin + n;
std::vector<char> want(begin, end);
EXPECT_EQ(got, want) << "block size = " << block_size
<< ", offset = " << offset << ", n = " << n;
}
}
}
}
TEST(RamFileBlockCacheTest, CacheHits) {
const size_t block_size = 16;
std::set<size_t> calls;
auto fetcher = [&calls, block_size](const string& filename, size_t offset,
size_t n, char* buffer,
size_t* bytes_transferred) {
EXPECT_EQ(n, block_size);
EXPECT_EQ(offset % block_size, 0);
EXPECT_EQ(calls.find(offset), calls.end()) << "at offset " << offset;
calls.insert(offset);
memset(buffer, 'x', n);
*bytes_transferred = n;
return OkStatus();
};
const uint32 block_count = 256;
RamFileBlockCache cache(block_size, block_count * block_size, 0, fetcher);
std::vector<char> out;
out.resize(block_count, 0);
for (int i = 0; i < 2; i++) {
for (int j = 0; j < block_count; j++) {
TF_EXPECT_OK(ReadCache(&cache, "", block_size * j, block_size, &out));
}
}
}
TEST(RamFileBlockCacheTest, OutOfRange) {
const size_t block_size = 16;
const size_t file_size = 24;
bool first_block = false;
bool second_block = false;
auto fetcher = [block_size, file_size, &first_block, &second_block](
const string& filename, size_t offset, size_t n,
char* buffer, size_t* bytes_transferred) {
EXPECT_EQ(n, block_size);
EXPECT_EQ(offset % block_size, 0);
size_t bytes_to_copy = 0;
if (offset == 0) {
memset(buffer, 'x', n);
bytes_to_copy = n;
first_block = true;
} else if (offset == block_size) {
bytes_to_copy = file_size - block_size;
memset(buffer, 'x', bytes_to_copy);
second_block = true;
}
*bytes_transferred = bytes_to_copy;
return OkStatus();
};
RamFileBlockCache cache(block_size, block_size, 0, fetcher);
std::vector<char> out;
TF_EXPECT_OK(ReadCache(&cache, "", 0, block_size, &out));
EXPECT_TRUE(first_block);
EXPECT_EQ(out.size(), block_size);
Status status = ReadCache(&cache, "", file_size + 4, 4, &out);
EXPECT_EQ(status.code(), error::OUT_OF_RANGE);
EXPECT_TRUE(second_block);
second_block = false;
TF_EXPECT_OK(ReadCache(&cache, "", block_size, block_size, &out));
EXPECT_FALSE(second_block);
EXPECT_EQ(out.size(), file_size - block_size);
}
TEST(RamFileBlockCacheTest, Inconsistent) {
const size_t block_size = 16;
auto fetcher = [block_size](const string& filename, size_t offset, size_t n,
char* buffer, size_t* bytes_transferred) {
EXPECT_EQ(n, block_size);
EXPECT_EQ(offset % block_size, 0);
EXPECT_GE(n, 1);
memset(buffer, 'x', 1);
*bytes_transferred = 1;
return OkStatus();
};
RamFileBlockCache cache(block_size, 2 * block_size, 0, fetcher);
std::vector<char> out;
TF_EXPECT_OK(ReadCache(&cache, "", block_size, block_size, &out));
EXPECT_EQ(out.size(), 1);
Status status = ReadCache(&cache, "", 0, block_size, &out);
EXPECT_EQ(status.code(), error::INTERNAL);
}
TEST(RamFileBlockCacheTest, LRU) {
const size_t block_size = 16;
std::list<size_t> calls;
auto fetcher = [&calls, block_size](const string& filename, size_t offset,
size_t n, char* buffer,
size_t* bytes_transferred) {
EXPECT_EQ(n, block_size);
EXPECT_FALSE(calls.empty()) << "at offset = " << offset;
if (!calls.empty()) {
EXPECT_EQ(offset, calls.front());
calls.pop_front();
}
memset(buffer, 'x', n);
*bytes_transferred = n;
return OkStatus();
};
const uint32 block_count = 2;
RamFileBlockCache cache(block_size, block_count * block_size, 0, fetcher);
std::vector<char> out;
calls.push_back(0);
TF_EXPECT_OK(ReadCache(&cache, "", 0, 1, &out));
TF_EXPECT_OK(ReadCache(&cache, "", 0, 1, &out));
calls.push_back(block_size);
TF_EXPECT_OK(ReadCache(&cache, "", block_size, 1, &out));
TF_EXPECT_OK(ReadCache(&cache, "", block_size, 1, &out));
calls.push_back(2 * block_size);
TF_EXPECT_OK(ReadCache(&cache, "", 2 * block_size, 1, &out));
TF_EXPECT_OK(ReadCache(&cache, "", 2 * block_size, 1, &out));
calls.push_back(0);
TF_EXPECT_OK(ReadCache(&cache, "", 0, 1, &out));
TF_EXPECT_OK(ReadCache(&cache, "", 2 * block_size, 1, &out));
calls.push_back(block_size);
TF_EXPECT_OK(ReadCache(&cache, "", block_size, 1, &out));
calls.push_back(0);
TF_EXPECT_OK(ReadCache(&cache, "", 0, 1, &out));
}
TEST(RamFileBlockCacheTest, MaxStaleness) {
int calls = 0;
auto fetcher = [&calls](const string& filename, size_t offset, size_t n,
char* buffer, size_t* bytes_transferred) {
calls++;
memset(buffer, 'x', n);
*bytes_transferred = n;
return OkStatus();
};
std::vector<char> out;
std::unique_ptr<NowSecondsEnv> env(new NowSecondsEnv);
RamFileBlockCache cache1(8, 16, 2 , fetcher, env.get());
TF_EXPECT_OK(ReadCache(&cache1, "", 0, 1, &out));
EXPECT_EQ(calls, 1);
for (int i = 1; i <= 10; i++) {
env->SetNowSeconds(i + 1);
TF_EXPECT_OK(ReadCache(&cache1, "", 0, 1, &out));
EXPECT_EQ(calls, 1 + i / 3);
}
calls = 0;
env->SetNowSeconds(0);
RamFileBlockCache cache2(8, 16, 0 , fetcher, env.get());
TF_EXPECT_OK(ReadCache(&cache2, "", 0, 1, &out));
EXPECT_EQ(calls, 1);
env->SetNowSeconds(365 * 24 * 60 * 60);
TF_EXPECT_OK(ReadCache(&cache2, "", 0, 1, &out));
EXPECT_EQ(calls, 1);
}
TEST(RamFileBlockCacheTest, RemoveFile) {
int calls = 0;
auto fetcher = [&calls](const string& filename, size_t offset, size_t n,
char* buffer, size_t* bytes_transferred) {
calls++;
char c = (filename == "a") ? 'a' : (filename == "b") ? 'b' : 'x';
if (offset > 0) {
c = toupper(c);
}
memset(buffer, c, n);
*bytes_transferred = n;
return OkStatus();
};
const size_t n = 3;
RamFileBlockCache cache(8, 32, 0, fetcher);
std::vector<char> out;
std::vector<char> a(n, 'a');
std::vector<char> b(n, 'b');
std::vector<char> A(n, 'A');
std::vector<char> B(n, 'B');
TF_EXPECT_OK(ReadCache(&cache, "a", 0, n, &out));
EXPECT_EQ(out, a);
EXPECT_EQ(calls, 1);
TF_EXPECT_OK(ReadCache(&cache, "a", 8, n, &out));
EXPECT_EQ(out, A);
EXPECT_EQ(calls, 2);
TF_EXPECT_OK(ReadCache(&cache, "b", 0, n, &out));
EXPECT_EQ(out, b);
EXPECT_EQ(calls, 3);
TF_EXPECT_OK(ReadCache(&cache, "b", 8, n, &out));
EXPECT_EQ(out, B);
EXPECT_EQ(calls, 4);
TF_EXPECT_OK(ReadCache(&cache, "a", 0, n, &out));
EXPECT_EQ(out, a);
TF_EXPECT_OK(ReadCache(&cache, "a", 8, n, &out));
EXPECT_EQ(out, A);
TF_EXPECT_OK(ReadCache(&cache, "b", 0, n, &out));
EXPECT_EQ(out, b);
TF_EXPECT_OK(ReadCache(&cache, "b", 8, n, &out));
EXPECT_EQ(out, B);
EXPECT_EQ(calls, 4);
cache.RemoveFile("a");
TF_EXPECT_OK(ReadCache(&cache, "b", 0, n, &out));
EXPECT_EQ(out, b);
TF_EXPECT_OK(ReadCache(&cache, "b", 8, n, &out));
EXPECT_EQ(out, B);
EXPECT_EQ(calls, 4);
TF_EXPECT_OK(ReadCache(&cache, "a", 0, n, &out));
EXPECT_EQ(out, a);
EXPECT_EQ(calls, 5);
TF_EXPECT_OK(ReadCache(&cache, "a", 8, n, &out));
EXPECT_EQ(out, A);
EXPECT_EQ(calls, 6);
}
TEST(RamFileBlockCacheTest, Prune) {
int calls = 0;
auto fetcher = [&calls](const string& filename, size_t offset, size_t n,
char* buffer, size_t* bytes_transferred) {
calls++;
memset(buffer, 'x', n);
*bytes_transferred = n;
return OkStatus();
};
std::vector<char> out;
std::unique_ptr<NowSecondsEnv> env(new NowSecondsEnv);
uint64 now = Env::Default()->NowSeconds();
env->SetNowSeconds(now);
RamFileBlockCache cache(8, 32, 1 , fetcher, env.get());
TF_EXPECT_OK(ReadCache(&cache, "a", 0, 1, &out));
env->SetNowSeconds(now + 1);
TF_EXPECT_OK(ReadCache(&cache, "b", 0, 1, &out));
TF_EXPECT_OK(ReadCache(&cache, "a", 8, 1, &out));
EXPECT_EQ(cache.CacheSize(), 24);
EXPECT_EQ(calls, 3);
TF_EXPECT_OK(ReadCache(&cache, "a", 0, 1, &out));
TF_EXPECT_OK(ReadCache(&cache, "b", 0, 1, &out));
TF_EXPECT_OK(ReadCache(&cache, "a", 8, 1, &out));
EXPECT_EQ(calls, 3);
env->SetNowSeconds(now + 2);
uint64 start = Env::Default()->NowSeconds();
do {
Env::Default()->SleepForMicroseconds(100000);
} while (cache.CacheSize() == 24 && Env::Default()->NowSeconds() - start < 3);
EXPECT_EQ(cache.CacheSize(), 8);
TF_EXPECT_OK(ReadCache(&cache, "b", 0, 1, &out));
EXPECT_EQ(calls, 3);
env->SetNowSeconds(now + 3);
start = Env::Default()->NowSeconds();
do {
Env::Default()->SleepForMicroseconds(100000);
} while (cache.CacheSize() == 8 && Env::Default()->NowSeconds() - start < 3);
EXPECT_EQ(cache.CacheSize(), 0);
}
TEST(RamFileBlockCacheTest, ParallelReads) {
const int callers = 4;
BlockingCounter counter(callers);
auto fetcher = [&counter](const string& filename, size_t offset, size_t n,
char* buffer, size_t* bytes_transferred) {
counter.DecrementCount();
if (!counter.WaitFor(std::chrono::seconds(10))) {
return errors::FailedPrecondition("desired concurrency not reached");
}
memset(buffer, 'x', n);
*bytes_transferred = n;
return OkStatus();
};
const int block_size = 8;
RamFileBlockCache cache(block_size, 2 * callers * block_size, 0, fetcher);
std::vector<std::unique_ptr<Thread>> threads;
for (int i = 0; i < callers; i++) {
threads.emplace_back(
Env::Default()->StartThread({}, "caller", [&cache, i, block_size]() {
std::vector<char> out;
TF_EXPECT_OK(
ReadCache(&cache, "a", i * block_size, block_size, &out));
std::vector<char> x(block_size, 'x');
EXPECT_EQ(out, x);
}));
}
}
TEST(RamFileBlockCacheTest, CoalesceConcurrentReads) {
const size_t block_size = 16;
int num_requests = 0;
Notification notification;
auto fetcher = [&num_requests, ¬ification, block_size](
const string& filename, size_t offset, size_t n,
char* buffer, size_t* bytes_transferred) {
EXPECT_EQ(n, block_size);
EXPECT_EQ(offset, 0);
num_requests++;
memset(buffer, 'x', n);
*bytes_transferred = n;
notification.Notify();
Env::Default()->SleepForMicroseconds(100000);
return OkStatus();
};
RamFileBlockCache cache(block_size, block_size, 0, fetcher);
std::unique_ptr<Thread> concurrent(
Env::Default()->StartThread({}, "concurrent", [&cache, block_size] {
std::vector<char> out;
TF_EXPECT_OK(ReadCache(&cache, "", 0, block_size / 2, &out));
EXPECT_EQ(out.size(), block_size / 2);
}));
notification.WaitForNotification();
std::vector<char> out;
TF_EXPECT_OK(ReadCache(&cache, "", block_size / 2, block_size / 2, &out));
EXPECT_EQ(out.size(), block_size / 2);
EXPECT_EQ(1, num_requests);
}
TEST(RamFileBlockCacheTest, Flush) {
int calls = 0;
auto fetcher = [&calls](const string& filename, size_t offset, size_t n,
char* buffer, size_t* bytes_transferred) {
calls++;
memset(buffer, 'x', n);
*bytes_transferred = n;
return OkStatus();
};
RamFileBlockCache cache(16, 32, 0, fetcher);
std::vector<char> out;
TF_EXPECT_OK(ReadCache(&cache, "", 0, 16, &out));
TF_EXPECT_OK(ReadCache(&cache, "", 0, 16, &out));
EXPECT_EQ(calls, 1);
cache.Flush();
TF_EXPECT_OK(ReadCache(&cache, "", 0, 16, &out));
EXPECT_EQ(calls, 2);
}
}
} |
2,608 | cpp | google/tsl | time_util | tsl/platform/cloud/time_util.cc | tsl/platform/cloud/time_util_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_CLOUD_TIME_UTIL_H_
#define TENSORFLOW_TSL_PLATFORM_CLOUD_TIME_UTIL_H_
#include "tsl/platform/status.h"
namespace tsl {
Status ParseRfc3339Time(const string& time, int64_t* mtime_nsec);
}
#endif
#include "tsl/platform/cloud/time_util.h"
#include <time.h>
#include <cmath>
#include <cstdio>
#include <ctime>
#ifdef _WIN32
#define timegm _mkgmtime
#endif
#include "tsl/platform/errors.h"
namespace tsl {
namespace {
constexpr int64_t kNanosecondsPerSecond = 1000 * 1000 * 1000;
}
Status ParseRfc3339Time(const string& time, int64_t* mtime_nsec) {
tm parsed{0};
float seconds;
if (sscanf(time.c_str(), "%4d-%2d-%2dT%2d:%2d:%fZ", &(parsed.tm_year),
&(parsed.tm_mon), &(parsed.tm_mday), &(parsed.tm_hour),
&(parsed.tm_min), &seconds) != 6) {
return errors::Internal(
strings::StrCat("Unrecognized RFC 3339 time format: ", time));
}
const int int_seconds = std::floor(seconds);
parsed.tm_year -= 1900;
parsed.tm_mon -= 1;
parsed.tm_sec = int_seconds;
*mtime_nsec = timegm(&parsed) * kNanosecondsPerSecond +
static_cast<int64_t>(std::floor((seconds - int_seconds) *
kNanosecondsPerSecond));
return OkStatus();
}
} | #include "tsl/platform/cloud/time_util.h"
#include "tsl/lib/core/status_test_util.h"
#include "tsl/platform/test.h"
namespace tsl {
TEST(TimeUtil, ParseRfc3339Time) {
int64_t mtime_nsec;
TF_EXPECT_OK(ParseRfc3339Time("2016-04-29T23:15:24.896Z", &mtime_nsec));
EXPECT_NEAR(1461971724896, mtime_nsec / 1000 / 1000, 1);
}
TEST(TimeUtil, ParseRfc3339Time_ParseError) {
int64_t mtime_nsec;
EXPECT_EQ("Unrecognized RFC 3339 time format: 2016-04-29",
ParseRfc3339Time("2016-04-29", &mtime_nsec).message());
}
} |
2,609 | cpp | google/tsl | google_auth_provider | tsl/platform/cloud/google_auth_provider.cc | tsl/platform/cloud/google_auth_provider_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_CLOUD_GOOGLE_AUTH_PROVIDER_H_
#define TENSORFLOW_TSL_PLATFORM_CLOUD_GOOGLE_AUTH_PROVIDER_H_
#include <memory>
#include "tsl/platform/cloud/auth_provider.h"
#include "tsl/platform/cloud/compute_engine_metadata_client.h"
#include "tsl/platform/cloud/oauth_client.h"
#include "tsl/platform/mutex.h"
#include "tsl/platform/thread_annotations.h"
namespace tsl {
class GoogleAuthProvider : public AuthProvider {
public:
GoogleAuthProvider(std::shared_ptr<ComputeEngineMetadataClient>
compute_engine_metadata_client);
explicit GoogleAuthProvider(std::unique_ptr<OAuthClient> oauth_client,
std::shared_ptr<ComputeEngineMetadataClient>
compute_engine_metadata_client,
Env* env);
virtual ~GoogleAuthProvider() {}
Status GetToken(string* token) override;
private:
Status GetTokenFromFiles() TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
Status GetTokenFromGce() TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
Status GetTokenForTesting() TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
std::unique_ptr<OAuthClient> oauth_client_;
std::shared_ptr<ComputeEngineMetadataClient> compute_engine_metadata_client_;
Env* env_;
mutex mu_;
string current_token_ TF_GUARDED_BY(mu_);
uint64 expiration_timestamp_sec_ TF_GUARDED_BY(mu_) = 0;
GoogleAuthProvider(const GoogleAuthProvider&) = delete;
void operator=(const GoogleAuthProvider&) = delete;
};
}
#endif
#include "tsl/platform/cloud/google_auth_provider.h"
#ifndef _WIN32
#include <pwd.h>
#include <unistd.h>
#else
#include <sys/types.h>
#endif
#include <fstream>
#include <utility>
#include "absl/strings/match.h"
#include "json/json.h"
#include "tsl/platform/base64.h"
#include "tsl/platform/env.h"
#include "tsl/platform/errors.h"
#include "tsl/platform/path.h"
#include "tsl/platform/retrying_utils.h"
namespace tsl {
namespace {
constexpr char kGoogleApplicationCredentials[] =
"GOOGLE_APPLICATION_CREDENTIALS";
constexpr char kGoogleAuthTokenForTesting[] = "GOOGLE_AUTH_TOKEN_FOR_TESTING";
constexpr char kCloudSdkConfig[] = "CLOUDSDK_CONFIG";
constexpr char kNoGceCheck[] = "NO_GCE_CHECK";
constexpr char kGCloudConfigFolder[] = ".config/gcloud/";
constexpr char kWellKnownCredentialsFile[] =
"application_default_credentials.json";
constexpr int kExpirationTimeMarginSec = 60;
constexpr char kOAuthV3Url[] = "https:
constexpr char kOAuthV4Url[] = "https:
constexpr char kGceTokenPath[] = "instance/service-accounts/default/token";
constexpr char kOAuthScope[] = "https:
bool IsFile(const string& filename) {
std::ifstream fstream(filename.c_str());
return fstream.good();
}
Status GetEnvironmentVariableFileName(string* filename) {
if (!filename) {
return errors::FailedPrecondition("'filename' cannot be nullptr.");
}
const char* result = std::getenv(kGoogleApplicationCredentials);
if (!result || !IsFile(result)) {
return errors::NotFound(strings::StrCat("$", kGoogleApplicationCredentials,
" is not set or corrupt."));
}
*filename = result;
return OkStatus();
}
Status GetWellKnownFileName(string* filename) {
if (!filename) {
return errors::FailedPrecondition("'filename' cannot be nullptr.");
}
string config_dir;
const char* config_dir_override = std::getenv(kCloudSdkConfig);
if (config_dir_override) {
config_dir = config_dir_override;
} else {
const char* home_dir = std::getenv("HOME");
if (!home_dir) {
return errors::FailedPrecondition("Could not read $HOME.");
}
config_dir = io::JoinPath(home_dir, kGCloudConfigFolder);
}
auto result = io::JoinPath(config_dir, kWellKnownCredentialsFile);
if (!IsFile(result)) {
return errors::NotFound(
"Could not find the credentials file in the standard gcloud location.");
}
*filename = result;
return OkStatus();
}
}
GoogleAuthProvider::GoogleAuthProvider(
std::shared_ptr<ComputeEngineMetadataClient> compute_engine_metadata_client)
: GoogleAuthProvider(std::unique_ptr<OAuthClient>(new OAuthClient()),
std::move(compute_engine_metadata_client),
Env::Default()) {}
GoogleAuthProvider::GoogleAuthProvider(
std::unique_ptr<OAuthClient> oauth_client,
std::shared_ptr<ComputeEngineMetadataClient> compute_engine_metadata_client,
Env* env)
: oauth_client_(std::move(oauth_client)),
compute_engine_metadata_client_(
std::move(compute_engine_metadata_client)),
env_(env) {}
Status GoogleAuthProvider::GetToken(string* t) {
mutex_lock lock(mu_);
const uint64 now_sec = env_->NowSeconds();
if (now_sec + kExpirationTimeMarginSec < expiration_timestamp_sec_) {
*t = current_token_;
return OkStatus();
}
if (GetTokenForTesting().ok()) {
*t = current_token_;
return OkStatus();
}
auto token_from_files_status = GetTokenFromFiles();
if (token_from_files_status.ok()) {
*t = current_token_;
return OkStatus();
}
char* no_gce_check_var = std::getenv(kNoGceCheck);
bool skip_gce_check = no_gce_check_var != nullptr &&
absl::EqualsIgnoreCase(no_gce_check_var, "true");
Status token_from_gce_status;
if (skip_gce_check) {
token_from_gce_status =
Status(absl::StatusCode::kCancelled,
strings::StrCat("GCE check skipped due to presence of $",
kNoGceCheck, " environment variable."));
} else {
token_from_gce_status = GetTokenFromGce();
}
if (token_from_gce_status.ok()) {
*t = current_token_;
return OkStatus();
}
if (skip_gce_check) {
LOG(INFO)
<< "Attempting an empty bearer token since no token was retrieved "
<< "from files, and GCE metadata check was skipped.";
} else {
LOG(WARNING)
<< "All attempts to get a Google authentication bearer token failed, "
<< "returning an empty token. Retrieving token from files failed with "
"\""
<< token_from_files_status.ToString() << "\"."
<< " Retrieving token from GCE failed with \""
<< token_from_gce_status.ToString() << "\".";
}
*t = "";
if (skip_gce_check) {
expiration_timestamp_sec_ = 0;
} else {
expiration_timestamp_sec_ = UINT64_MAX;
}
current_token_ = "";
return OkStatus();
}
Status GoogleAuthProvider::GetTokenFromFiles() {
string credentials_filename;
if (!GetEnvironmentVariableFileName(&credentials_filename).ok() &&
!GetWellKnownFileName(&credentials_filename).ok()) {
return errors::NotFound("Could not locate the credentials file.");
}
Json::Value json;
Json::Reader reader;
std::ifstream credentials_fstream(credentials_filename);
if (!reader.parse(credentials_fstream, json)) {
return errors::FailedPrecondition(
"Couldn't parse the JSON credentials file.");
}
if (json.isMember("refresh_token")) {
TF_RETURN_IF_ERROR(oauth_client_->GetTokenFromRefreshTokenJson(
json, kOAuthV3Url, ¤t_token_, &expiration_timestamp_sec_));
} else if (json.isMember("private_key")) {
TF_RETURN_IF_ERROR(oauth_client_->GetTokenFromServiceAccountJson(
json, kOAuthV4Url, kOAuthScope, ¤t_token_,
&expiration_timestamp_sec_));
} else {
return errors::FailedPrecondition(
"Unexpected content of the JSON credentials file.");
}
return OkStatus();
}
Status GoogleAuthProvider::GetTokenFromGce() {
std::vector<char> response_buffer;
const uint64 request_timestamp_sec = env_->NowSeconds();
TF_RETURN_IF_ERROR(compute_engine_metadata_client_->GetMetadata(
kGceTokenPath, &response_buffer));
StringPiece response =
StringPiece(&response_buffer[0], response_buffer.size());
TF_RETURN_IF_ERROR(oauth_client_->ParseOAuthResponse(
response, request_timestamp_sec, ¤t_token_,
&expiration_timestamp_sec_));
return OkStatus();
}
Status GoogleAuthProvider::GetTokenForTesting() {
const char* token = std::getenv(kGoogleAuthTokenForTesting);
if (!token) {
return errors::NotFound("The env variable for testing was not set.");
}
expiration_timestamp_sec_ = UINT64_MAX;
current_token_ = token;
return OkStatus();
}
} | #include "tsl/platform/cloud/google_auth_provider.h"
#include <stdlib.h>
#include "tsl/lib/core/status_test_util.h"
#include "tsl/platform/cloud/http_request_fake.h"
#include "tsl/platform/path.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace {
string TestData() {
return io::JoinPath(testing::TslSrcRoot(), "platform", "cloud", "testdata");
}
class FakeEnv : public EnvWrapper {
public:
FakeEnv() : EnvWrapper(Env::Default()) {}
uint64 NowSeconds() const override { return now; }
uint64 now = 10000;
};
class FakeOAuthClient : public OAuthClient {
public:
Status GetTokenFromServiceAccountJson(
Json::Value json, StringPiece oauth_server_uri, StringPiece scope,
string* token, uint64* expiration_timestamp_sec) override {
provided_credentials_json = json;
*token = return_token;
*expiration_timestamp_sec = return_expiration_timestamp;
return OkStatus();
}
Status GetTokenFromRefreshTokenJson(
Json::Value json, StringPiece oauth_server_uri, string* token,
uint64* expiration_timestamp_sec) override {
provided_credentials_json = json;
*token = return_token;
*expiration_timestamp_sec = return_expiration_timestamp;
return OkStatus();
}
string return_token;
uint64 return_expiration_timestamp;
Json::Value provided_credentials_json;
};
}
class GoogleAuthProviderTest : public ::testing::Test {
protected:
void SetUp() override { ClearEnvVars(); }
void TearDown() override { ClearEnvVars(); }
void ClearEnvVars() {
unsetenv("CLOUDSDK_CONFIG");
unsetenv("GOOGLE_APPLICATION_CREDENTIALS");
unsetenv("GOOGLE_AUTH_TOKEN_FOR_TESTING");
unsetenv("NO_GCE_CHECK");
}
};
TEST_F(GoogleAuthProviderTest, EnvironmentVariable_Caching) {
setenv("GOOGLE_APPLICATION_CREDENTIALS",
io::JoinPath(TestData(), "service_account_credentials.json").c_str(),
1);
setenv("CLOUDSDK_CONFIG", TestData().c_str(),
1);
auto oauth_client = new FakeOAuthClient;
std::vector<HttpRequest*> requests;
FakeEnv env;
std::shared_ptr<HttpRequest::Factory> fakeHttpRequestFactory =
std::make_shared<FakeHttpRequestFactory>(&requests);
auto metadataClient = std::make_shared<ComputeEngineMetadataClient>(
fakeHttpRequestFactory, RetryConfig(0 ));
GoogleAuthProvider provider(std::unique_ptr<OAuthClient>(oauth_client),
metadataClient, &env);
oauth_client->return_token = "fake-token";
oauth_client->return_expiration_timestamp = env.NowSeconds() + 3600;
string token;
TF_EXPECT_OK(provider.GetToken(&token));
EXPECT_EQ("fake-token", token);
EXPECT_EQ("fake_key_id",
oauth_client->provided_credentials_json.get("private_key_id", "")
.asString());
oauth_client->return_token = "new-fake-token";
env.now += 3000;
TF_EXPECT_OK(provider.GetToken(&token));
EXPECT_EQ("fake-token", token);
env.now += 598;
TF_EXPECT_OK(provider.GetToken(&token));
EXPECT_EQ("new-fake-token", token);
}
TEST_F(GoogleAuthProviderTest, GCloudRefreshToken) {
setenv("CLOUDSDK_CONFIG", TestData().c_str(), 1);
auto oauth_client = new FakeOAuthClient;
std::vector<HttpRequest*> requests;
FakeEnv env;
std::shared_ptr<HttpRequest::Factory> fakeHttpRequestFactory =
std::make_shared<FakeHttpRequestFactory>(&requests);
auto metadataClient = std::make_shared<ComputeEngineMetadataClient>(
fakeHttpRequestFactory, RetryConfig(0 ));
GoogleAuthProvider provider(std::unique_ptr<OAuthClient>(oauth_client),
metadataClient, &env);
oauth_client->return_token = "fake-token";
oauth_client->return_expiration_timestamp = env.NowSeconds() + 3600;
string token;
TF_EXPECT_OK(provider.GetToken(&token));
EXPECT_EQ("fake-token", token);
EXPECT_EQ("fake-refresh-token",
oauth_client->provided_credentials_json.get("refresh_token", "")
.asString());
}
TEST_F(GoogleAuthProviderTest, RunningOnGCE) {
auto oauth_client = new FakeOAuthClient;
std::vector<HttpRequest*> requests(
{new FakeHttpRequest(
"Uri: http:
"/service-accounts/default/token\n"
"Header Metadata-Flavor: Google\n",
R"(
{
"access_token":"fake-gce-token",
"expires_in": 3920,
"token_type":"Bearer"
})"),
new FakeHttpRequest(
"Uri: http:
"/service-accounts/default/token\n"
"Header Metadata-Flavor: Google\n",
"", errors::Unavailable("503"), 503),
new FakeHttpRequest(
"Uri: http:
"/service-accounts/default/token\n"
"Header Metadata-Flavor: Google\n",
R"(
{
"access_token":"new-fake-gce-token",
"expires_in": 3920,
"token_type":"Bearer"
})")});
FakeEnv env;
std::shared_ptr<HttpRequest::Factory> fakeHttpRequestFactory =
std::make_shared<FakeHttpRequestFactory>(&requests);
auto metadataClient = std::make_shared<ComputeEngineMetadataClient>(
fakeHttpRequestFactory, RetryConfig(0 ));
GoogleAuthProvider provider(std::unique_ptr<OAuthClient>(oauth_client),
metadataClient, &env);
string token;
TF_EXPECT_OK(provider.GetToken(&token));
EXPECT_EQ("fake-gce-token", token);
env.now += 3700;
TF_EXPECT_OK(provider.GetToken(&token));
EXPECT_EQ("fake-gce-token", token);
env.now += 598;
TF_EXPECT_OK(provider.GetToken(&token));
EXPECT_EQ("new-fake-gce-token", token);
}
TEST_F(GoogleAuthProviderTest, OverrideForTesting) {
setenv("GOOGLE_AUTH_TOKEN_FOR_TESTING", "tokenForTesting", 1);
auto oauth_client = new FakeOAuthClient;
std::vector<HttpRequest*> empty_requests;
FakeEnv env;
std::shared_ptr<HttpRequest::Factory> fakeHttpRequestFactory =
std::make_shared<FakeHttpRequestFactory>(&empty_requests);
auto metadataClient = std::make_shared<ComputeEngineMetadataClient>(
fakeHttpRequestFactory, RetryConfig(0 ));
GoogleAuthProvider provider(std::unique_ptr<OAuthClient>(oauth_client),
metadataClient, &env);
string token;
TF_EXPECT_OK(provider.GetToken(&token));
EXPECT_EQ("tokenForTesting", token);
}
TEST_F(GoogleAuthProviderTest, NothingAvailable) {
auto oauth_client = new FakeOAuthClient;
std::vector<HttpRequest*> requests({new FakeHttpRequest(
"Uri: http:
"/service-accounts/default/token\n"
"Header Metadata-Flavor: Google\n",
"", errors::NotFound("404"), 404)});
FakeEnv env;
std::shared_ptr<HttpRequest::Factory> fakeHttpRequestFactory =
std::make_shared<FakeHttpRequestFactory>(&requests);
auto metadataClient = std::make_shared<ComputeEngineMetadataClient>(
fakeHttpRequestFactory, RetryConfig(0 ));
GoogleAuthProvider provider(std::unique_ptr<OAuthClient>(oauth_client),
metadataClient, &env);
string token;
TF_EXPECT_OK(provider.GetToken(&token));
EXPECT_EQ("", token);
}
TEST_F(GoogleAuthProviderTest, NoGceCheckEnvironmentVariable) {
setenv("NO_GCE_CHECK", "True", 1);
auto oauth_client = new FakeOAuthClient;
FakeEnv env;
GoogleAuthProvider provider(std::unique_ptr<OAuthClient>(oauth_client),
nullptr, &env);
string token;
TF_EXPECT_OK(provider.GetToken(&token));
EXPECT_EQ("", token);
setenv("NO_GCE_CHECK", "true", 1);
TF_EXPECT_OK(provider.GetToken(&token));
EXPECT_EQ("", token);
setenv("GOOGLE_AUTH_TOKEN_FOR_TESTING", "newToken", 1);
TF_EXPECT_OK(provider.GetToken(&token));
EXPECT_EQ("newToken", token);
}
} |
2,610 | cpp | google/tsl | gcs_file_system | tsl/platform/cloud/gcs_file_system.cc | tsl/platform/cloud/gcs_file_system_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_CLOUD_GCS_FILE_SYSTEM_H_
#define TENSORFLOW_TSL_PLATFORM_CLOUD_GCS_FILE_SYSTEM_H_
#include <string>
#include <unordered_set>
#include <utility>
#include <vector>
#include "tsl/platform/cloud/auth_provider.h"
#include "tsl/platform/cloud/compute_engine_metadata_client.h"
#include "tsl/platform/cloud/compute_engine_zone_provider.h"
#include "tsl/platform/cloud/expiring_lru_cache.h"
#include "tsl/platform/cloud/file_block_cache.h"
#include "tsl/platform/cloud/gcs_dns_cache.h"
#include "tsl/platform/cloud/gcs_throttle.h"
#include "tsl/platform/cloud/http_request.h"
#include "tsl/platform/file_system.h"
#include "tsl/platform/retrying_file_system.h"
#include "tsl/platform/status.h"
namespace tsl {
class GcsFileSystem;
constexpr char kBlockSize[] = "GCS_READ_CACHE_BLOCK_SIZE_MB";
#if defined(LIBTPU_ON_GCE)
constexpr size_t kDefaultBlockSize = 512 * 1024 * 1024;
#else
constexpr size_t kDefaultBlockSize = 64 * 1024 * 1024;
#endif
constexpr char kMaxCacheSize[] = "GCS_READ_CACHE_MAX_SIZE_MB";
#if defined(LIBTPU_ON_GCE)
constexpr size_t kDefaultMaxCacheSize = 163840LL * 1024LL * 1024LL;
#else
constexpr size_t kDefaultMaxCacheSize = 0;
#endif
constexpr char kMaxStaleness[] = "GCS_READ_CACHE_MAX_STALENESS";
constexpr uint64 kDefaultMaxStaleness = 0;
template <typename T>
bool GetEnvVar(const char* varname, bool (*convert)(StringPiece, T*),
T* value) {
const char* env_value = std::getenv(varname);
if (env_value == nullptr) {
return false;
}
return convert(env_value, value);
}
class GcsStatsInterface {
public:
virtual void Configure(GcsFileSystem* fs, GcsThrottle* throttle,
const FileBlockCache* block_cache) = 0;
virtual void RecordBlockLoadRequest(const string& file, size_t offset) = 0;
virtual void RecordBlockRetrieved(const string& file, size_t offset,
size_t bytes_transferred) = 0;
virtual void RecordStatObjectRequest() = 0;
virtual HttpRequest::RequestStats* HttpStats() = 0;
virtual ~GcsStatsInterface() = default;
};
struct UploadSessionHandle {
std::string session_uri;
bool resumable;
};
class GcsFileSystem : public FileSystem {
public:
struct TimeoutConfig;
explicit GcsFileSystem(bool make_default_cache = true);
GcsFileSystem(std::unique_ptr<AuthProvider> auth_provider,
std::unique_ptr<HttpRequest::Factory> http_request_factory,
std::unique_ptr<ZoneProvider> zone_provider, size_t block_size,
size_t max_bytes, uint64 max_staleness,
uint64 stat_cache_max_age, size_t stat_cache_max_entries,
uint64 matching_paths_cache_max_age,
size_t matching_paths_cache_max_entries,
RetryConfig retry_config, TimeoutConfig timeouts,
const std::unordered_set<string>& allowed_locations,
std::pair<const string, const string>* additional_header,
bool compose_append);
TF_USE_FILESYSTEM_METHODS_WITH_NO_TRANSACTION_SUPPORT;
Status NewRandomAccessFile(
const string& fname, TransactionToken* token,
std::unique_ptr<RandomAccessFile>* result) override;
Status NewWritableFile(const string& fname, TransactionToken* token,
std::unique_ptr<WritableFile>* result) override;
Status NewAppendableFile(const string& fname, TransactionToken* token,
std::unique_ptr<WritableFile>* result) override;
Status NewReadOnlyMemoryRegionFromFile(
const string& fname, TransactionToken* token,
std::unique_ptr<ReadOnlyMemoryRegion>* result) override;
Status FileExists(const string& fname, TransactionToken* token) override;
Status Stat(const string& fname, TransactionToken* token,
FileStatistics* stat) override;
Status GetChildren(const string& dir, TransactionToken* token,
std::vector<string>* result) override;
Status GetMatchingPaths(const string& pattern, TransactionToken* token,
std::vector<string>* results) override;
Status DeleteFile(const string& fname, TransactionToken* token) override;
Status CreateDir(const string& dirname, TransactionToken* token) override;
Status DeleteDir(const string& dirname, TransactionToken* token) override;
Status GetFileSize(const string& fname, TransactionToken* token,
uint64* file_size) override;
Status RenameFile(const string& src, const string& target,
TransactionToken* token) override;
Status IsDirectory(const string& fname, TransactionToken* token) override;
Status DeleteRecursively(const string& dirname, TransactionToken* token,
int64_t* undeleted_files,
int64_t* undeleted_dirs) override;
void FlushCaches(TransactionToken* token) override;
void SetStats(GcsStatsInterface* stats);
void SetCacheStats(FileBlockCacheStatsInterface* cache_stats);
size_t block_size() {
tf_shared_lock l(block_cache_lock_);
return file_block_cache_->block_size();
}
size_t max_bytes() {
tf_shared_lock l(block_cache_lock_);
return file_block_cache_->max_bytes();
}
uint64 max_staleness() {
tf_shared_lock l(block_cache_lock_);
return file_block_cache_->max_staleness();
}
TimeoutConfig timeouts() const { return timeouts_; }
std::unordered_set<string> allowed_locations() const {
return allowed_locations_;
}
bool compose_append() const { return compose_append_; }
string additional_header_name() const {
return additional_header_ ? additional_header_->first : "";
}
string additional_header_value() const {
return additional_header_ ? additional_header_->second : "";
}
uint64 stat_cache_max_age() const { return stat_cache_->max_age(); }
size_t stat_cache_max_entries() const { return stat_cache_->max_entries(); }
uint64 matching_paths_cache_max_age() const {
return matching_paths_cache_->max_age();
}
size_t matching_paths_cache_max_entries() const {
return matching_paths_cache_->max_entries();
}
struct TimeoutConfig {
uint32 connect = 120;
uint32 idle = 60;
uint32 metadata = 3600;
uint32 read = 3600;
uint32 write = 3600;
TimeoutConfig() {}
TimeoutConfig(uint32 connect, uint32 idle, uint32 metadata, uint32 read,
uint32 write)
: connect(connect),
idle(idle),
metadata(metadata),
read(read),
write(write) {}
};
Status CreateHttpRequest(std::unique_ptr<HttpRequest>* request);
void SetAuthProvider(std::unique_ptr<AuthProvider> auth_provider);
void ResetFileBlockCache(size_t block_size_bytes, size_t max_bytes,
uint64 max_staleness_secs);
protected:
virtual std::unique_ptr<FileBlockCache> MakeFileBlockCache(
size_t block_size, size_t max_bytes, uint64 max_staleness);
virtual Status LoadBufferFromGCS(const string& fname, size_t offset, size_t n,
char* buffer, size_t* bytes_transferred);
virtual Status CreateNewUploadSession(uint64 start_offset,
const std::string& object_to_upload,
const std::string& bucket,
uint64 file_size,
const std::string& gcs_path,
UploadSessionHandle* session_handle);
virtual Status UploadToSession(const std::string& session_uri,
uint64 start_offset, uint64 already_uploaded,
const std::string& tmp_content_filename,
uint64 file_size,
const std::string& file_path);
virtual Status RequestUploadSessionStatus(const string& session_uri,
uint64 file_size,
const std::string& gcs_path,
bool* completed, uint64* uploaded);
Status ParseGcsPathForScheme(StringPiece fname, string scheme,
bool empty_object_ok, string* bucket,
string* object);
virtual Status ParseGcsPath(StringPiece fname, bool empty_object_ok,
string* bucket, string* object);
std::shared_ptr<ComputeEngineMetadataClient> compute_engine_metadata_client_;
TimeoutConfig timeouts_;
RetryConfig retry_config_;
private:
struct GcsFileStat {
FileStatistics base;
int64_t generation_number = 0;
};
Status BucketExists(const string& bucket, bool* result);
Status GetBucketLocation(const string& bucket, string* location);
Status CheckBucketLocationConstraint(const string& bucket);
Status GetBucketMetadata(const string& bucket,
std::vector<char>* result_buffer);
Status ObjectExists(const string& fname, const string& bucket,
const string& object, bool* result);
Status FolderExists(const string& dirname, bool* result);
Status GetChildrenBounded(const string& dir, uint64 max_results,
std::vector<string>* result, bool recursively,
bool include_self_directory_marker);
Status StatForObject(const string& fname, const string& bucket,
const string& object, GcsFileStat* stat);
Status UncachedStatForObject(const string& fname, const string& bucket,
const string& object, GcsFileStat* stat);
Status RenameObject(const string& src, const string& target);
void ClearFileCaches(const string& fname);
mutex mu_;
std::unique_ptr<AuthProvider> auth_provider_ TF_GUARDED_BY(mu_);
std::shared_ptr<HttpRequest::Factory> http_request_factory_;
std::unique_ptr<ZoneProvider> zone_provider_;
uint64 block_size_;
mutex block_cache_lock_;
std::unique_ptr<FileBlockCache> file_block_cache_
TF_GUARDED_BY(block_cache_lock_);
bool cache_enabled_;
std::unique_ptr<GcsDnsCache> dns_cache_;
GcsThrottle throttle_;
using StatCache = ExpiringLRUCache<GcsFileStat>;
std::unique_ptr<StatCache> stat_cache_;
using MatchingPathsCache = ExpiringLRUCache<std::vector<string>>;
std::unique_ptr<MatchingPathsCache> matching_paths_cache_;
using BucketLocationCache = ExpiringLRUCache<string>;
std::unique_ptr<BucketLocationCache> bucket_location_cache_;
std::unordered_set<string> allowed_locations_;
bool compose_append_;
GcsStatsInterface* stats_ = nullptr;
std::unique_ptr<std::pair<const string, const string>> additional_header_;
GcsFileSystem(const GcsFileSystem&) = delete;
void operator=(const GcsFileSystem&) = delete;
};
class RetryingGcsFileSystem : public RetryingFileSystem<GcsFileSystem> {
public:
RetryingGcsFileSystem();
};
}
#endif
#include "tsl/platform/cloud/gcs_file_system.h"
#include <stdio.h>
#include "absl/status/status.h"
#include "absl/strings/str_cat.h"
#ifndef _WIN32
#include <unistd.h>
#endif
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <string>
#include <utility>
#include <vector>
#include "tsl/platform/file_statistics.h"
#include "tsl/platform/strcat.h"
#ifdef _WIN32
#include <io.h>
#endif
#include "absl/base/macros.h"
#include "json/json.h"
#include "tsl/platform/cloud/curl_http_request.h"
#include "tsl/platform/cloud/file_block_cache.h"
#include "tsl/platform/cloud/google_auth_provider.h"
#include "tsl/platform/cloud/ram_file_block_cache.h"
#include "tsl/platform/cloud/time_util.h"
#include "tsl/platform/env.h"
#include "tsl/platform/errors.h"
#include "tsl/platform/mutex.h"
#include "tsl/platform/numbers.h"
#include "tsl/platform/path.h"
#include "tsl/platform/protobuf.h"
#include "tsl/platform/retrying_utils.h"
#include "tsl/platform/str_util.h"
#include "tsl/platform/stringprintf.h"
#include "tsl/platform/thread_annotations.h"
#include "tsl/profiler/lib/traceme.h"
#ifdef _WIN32
#ifdef DeleteFile
#undef DeleteFile
#endif
#endif
namespace tsl {
namespace {
constexpr char kGcsUriBase[] = "https:
constexpr char kGcsUploadUriBase[] =
"https:
constexpr char kStorageHost[] = "storage.googleapis.com";
constexpr char kBucketMetadataLocationKey[] = "location";
constexpr size_t kReadAppendableFileBufferSize = 1024 * 1024;
constexpr int kGetChildrenDefaultPageSize = 1000;
constexpr uint64 HTTP_CODE_RESUME_INCOMPLETE = 308;
constexpr uint64 HTTP_CODE_PRECONDITION_FAILED = 412;
ABSL_DEPRECATED("Use GCS_READ_CACHE_BLOCK_SIZE_MB instead.")
constexpr char kReadaheadBufferSize[] = "GCS_READAHEAD_BUFFER_SIZE_BYTES";
constexpr char kStatCacheMaxAge[] = "GCS_STAT_CACHE_MAX_AGE";
constexpr uint64 kStatCacheDefaultMaxAge = 5;
constexpr char kStatCacheMaxEntries[] = "GCS_STAT_CACHE_MAX_ENTRIES";
constexpr size_t kStatCacheDefaultMaxEntries = 1024;
constexpr char kMatchingPathsCacheMaxAge[] = "GCS_MATCHING_PATHS_CACHE_MAX_AGE";
constexpr uint64 kMatchingPathsCacheDefaultMaxAge = 0;
constexpr char kMatchingPathsCacheMaxEntries[] =
"GCS_MATCHING_PATHS_CACHE_MAX_ENTRIES";
constexpr size_t kMatchingPathsCacheDefaultMaxEntries = 1024;
constexpr size_t kBucketLocationCacheMaxEntries = 10;
constexpr size_t kCacheNeverExpire = std::numeric_limits<uint64>::max();
const FileStatistics DIRECTORY_STAT(0, 0, true);
constexpr char kResolveCacheSecs[] = "GCS_RESOLVE_REFRESH_SECS";
constexpr char kRequestConnectionTimeout[] =
"GCS_REQUEST_CONNECTION_TIMEOUT_SECS";
constexpr char kRequestIdleTimeout[] = "GCS_REQUEST_IDLE_TIMEOUT_SECS";
constexpr char kMetadataRequestTimeout[] = "GCS_METADATA_REQUEST_TIMEOUT_SECS";
constexpr char kReadRequestTimeout[] = "GCS_READ_REQUEST_TIMEOUT_SECS";
constexpr char kWriteRequestTimeout[] = "GCS_WRITE_REQUEST_TIMEOUT_SECS";
constexpr char kAdditionalRequestHeader[] = "GCS_ADDITIONAL_REQUEST_HEADER";
constexpr char kThrottleRate[] = "GCS_THROTTLE_TOKEN_RATE";
constexpr char kThrottleBucket[] = "GCS_THROTTLE_BUCKET_SIZE";
constexpr char kTokensPerRequest[] = "GCS_TOKENS_PER_REQUEST";
constexpr char kInitialTokens[] = "GCS_INITIAL_TOKENS";
constexpr char kRetryConfigInitialDelayTimeUs[] =
"GCS_RETRY_CONFIG_INIT_DELAY_TIME_US";
constexpr char kRetryConfigMaxDelayTimeUs[] =
"GCS_RETRY_CONFIG_MAX_DELAY_TIME_US";
constexpr char kRetryConfigMaxRetries[] = "GCS_RETRY_CONFIG_MAX_RETRIES";
constexpr char kAllowedBucketLocations[] = "GCS_ALLOWED_BUCKET_LOCATIONS";
constexpr char kDetectZoneSentinelValue[] = "auto";
constexpr char kAppendMode[] = "GCS_APPEND_MODE";
constexpr char kComposeAppend[] = "compose";
Status GetTmpFilename(string* filename) {
*filename = io::GetTempFilename("");
return OkStatus();
}
string MaybeAppendSlash(const string& name) {
if (name.empty()) {
return "/";
}
if (name.back() != '/') {
return strings::StrCat(name, "/");
}
return name;
}
string JoinGcsPath(const string& path, const string& subpath) {
return strings::StrCat(MaybeAppendSlash(path), subpath);
}
std::set<string> AddAllSubpaths(const std::vector<string>& paths) {
std::set<string> result;
result.insert(paths.begin(), paths.end());
for (const string& path : paths) {
StringPiece subpath = io::Dirname(path);
while (!(subpath.empty() || subpath == "/")) {
result.emplace(string(subpath));
subpath = io::Dirname(subpath);
}
}
return result;
}
Status ParseJson(StringPiece json, Json::Value* result) {
Json::Reader reader;
if (!reader.parse(json.data(), json.data() + json.size(), *result)) {
return errors::Internal("Couldn't parse JSON response from GCS.");
}
return OkStatus();
}
Status ParseJson(const std::vector<char>& json, Json::Value* result) {
return ParseJson(StringPiece{json.data(), json.size()}, result);
}
Status GetValue(const Json::Value& parent, const char* name,
Json::Value* result) {
*result = parent.get(name, Json::Value::null);
if (result->isNull()) {
return errors::Internal("The field '", name,
"' was expected in the JSON response.");
}
return OkStatus();
}
Status GetStringValue(const Json::Value& parent, const char* name,
string* result) {
Json::Value result_value;
TF_RETURN_IF_ERROR(GetValue(parent, name, &result_value));
if (!result_value.isString()) {
return errors::Internal(
"The field '", name,
"' in the JSON response was expected to be a string.");
}
*result = result_value.asString();
return OkStatus();
}
Status GetInt64Value(const Json::Value& parent, const char* name,
int64_t* result) {
Json::Value result_value;
TF_RETURN_IF_ERROR(GetValue(parent, name, &result_value));
if (result_value.isNumeric()) {
*result = result_value.asInt64();
return OkStatus();
}
if (result_value.isString() &&
strings::safe_strto64(result_value.asCString(), result)) {
return OkStatus();
}
return errors::Internal(
"The field '", name,
"' in the JSON response was expected to be a number.");
}
Status GetBoolValue(const Json::Value& parent, const char* name, bool* result) {
Json::Value result_value;
TF_RETURN_IF_ERROR(GetValue(parent, name, &result_value));
if (!result_value.isBool()) {
return errors::Internal(
"The field '", name,
"' in the JSON response was expected to be a boolean.");
}
*result = result_value.asBool();
return OkStatus();
}
RetryConfig GetGcsRetryConfig() {
RetryConfig retryConfig(
1000 * 1000,
32 * 1000 * 1000,
10);
uint64 init_delay_time_us;
if (GetEnvVar(kRetryConfigInitialDelayTimeUs, strings::safe_strtou64,
&init_delay_time_us)) {
retryConfig.init_delay_time_us = init_delay_time_us;
}
uint64 max_delay_time_us;
if (GetEnvVar(kRetryConfigMaxDelayTimeUs, strings::safe_strtou64,
&max_delay_time_us)) {
retryConfig.max_delay_time_us = max_delay_time_us;
}
uint32 max_retries;
if (GetEnvVar(kRetryConfigMaxRetries, strings::safe_strtou32, &max_retries)) {
retryConfig.max_retries = max_retries;
}
VLOG(1) << "GCS RetryConfig: "
<< "init_delay_time_us = " << retryConfig.init_delay_time_us << " ; "
<< "max_delay_time_us = " << retryConfig.max_delay_time_us << " ; "
<< "max_retries = " << retryConfig.max_retries;
return retryConfig;
}
class GcsRandomAccessFile : public RandomAccessFile {
public:
using ReadFn =
std::function<Status(const string& filename, uint64 offset, size_t n,
StringPiece* result, char* scratch)>;
GcsRandomAccessFile(const string& filename, ReadFn read_fn)
: filename_(filename), read_fn_(std::move(read_fn)) {}
Status Name(StringPiece* result) const override {
*result = filename_;
return OkStatus();
}
Status Read(uint64 offset, size_t n, StringPiece* result,
char* scratch) const override {
return read_fn_(filename_, offset, n, result, scratch);
}
private:
const string filename_;
const ReadFn read_fn_;
};
class BufferedGcsRandomAccessFile : public RandomAccessFile {
public:
using ReadFn =
std::function<Status(const string& filename, uint64 offset, size_t n,
StringPiece* result, char* scratch)>;
BufferedGcsRandomAccessFile(const string& filename, uint64 buffer_size,
ReadFn read_fn)
: filename_(filename), | #include "tsl/platform/cloud/gcs_file_system.h"
#include <fstream>
#include "tsl/lib/core/status_test_util.h"
#include "tsl/platform/cloud/http_request_fake.h"
#include "tsl/platform/errors.h"
#include "tsl/platform/str_util.h"
#include "tsl/platform/strcat.h"
#include "tsl/platform/test.h"
#ifdef PLATFORM_WINDOWS
#undef DeleteFile
#endif
namespace tsl {
namespace {
static GcsFileSystem::TimeoutConfig kTestTimeoutConfig(5, 1, 10, 20, 30);
static RetryConfig kTestRetryConfig(0 );
static std::unordered_set<string>* kAllowedLocationsDefault =
new std::unordered_set<string>();
static std::unordered_set<string>* kAllowedLocationsAuto =
new std::unordered_set<string>({"auto"});
class FakeAuthProvider : public AuthProvider {
public:
Status GetToken(string* token) override {
*token = "fake_token";
return OkStatus();
}
};
class FakeZoneProvider : public ZoneProvider {
public:
Status GetZone(string* zone) override {
*zone = "us-east1-b";
return OkStatus();
}
};
TEST(GcsFileSystemTest, NewRandomAccessFile_NoBlockCache) {
std::vector<HttpRequest*> requests(
{new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 0-5\n"
"Timeouts: 5 1 20\n",
"012345"),
new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 6-11\n"
"Timeouts: 5 1 20\n",
"6789")});
GcsFileSystem fs(
std::unique_ptr<AuthProvider>(new FakeAuthProvider),
std::unique_ptr<HttpRequest::Factory>(
new FakeHttpRequestFactory(&requests)),
std::unique_ptr<ZoneProvider>(new FakeZoneProvider), 0 ,
0 , 0 , 0 ,
0 , 0 ,
0 , kTestRetryConfig,
kTestTimeoutConfig, *kAllowedLocationsDefault,
nullptr , false );
std::unique_ptr<RandomAccessFile> file;
TF_EXPECT_OK(
fs.NewRandomAccessFile("gs:
StringPiece filename;
TF_EXPECT_OK(file->Name(&filename));
EXPECT_EQ(filename, "gs:
char scratch[6];
StringPiece result;
TF_EXPECT_OK(file->Read(0, sizeof(scratch), &result, scratch));
EXPECT_EQ("012345", result);
EXPECT_TRUE(errors::IsOutOfRange(
file->Read(sizeof(scratch), sizeof(scratch), &result, scratch)));
EXPECT_EQ("6789", result);
}
TEST(GcsFileSystemTest, NewRandomAccessFile_Buffered) {
std::vector<HttpRequest*> requests({
new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 0-9\n"
"Timeouts: 5 1 20\n",
"0123456789"),
new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 10-19\n"
"Timeouts: 5 1 20\n",
""),
});
GcsFileSystem fs(
std::unique_ptr<AuthProvider>(new FakeAuthProvider),
std::unique_ptr<HttpRequest::Factory>(
new FakeHttpRequestFactory(&requests)),
std::unique_ptr<ZoneProvider>(new FakeZoneProvider), 10 ,
0 , 0 , 0 ,
0 , 0 ,
0 , kTestRetryConfig,
kTestTimeoutConfig, *kAllowedLocationsDefault,
nullptr , false );
std::unique_ptr<RandomAccessFile> file;
TF_EXPECT_OK(
fs.NewRandomAccessFile("gs:
StringPiece filename;
TF_EXPECT_OK(file->Name(&filename));
EXPECT_EQ(filename, "gs:
char scratch[6];
StringPiece result;
TF_EXPECT_OK(file->Read(0, sizeof(scratch), &result, scratch));
EXPECT_EQ("012345", result);
EXPECT_TRUE(errors::IsOutOfRange(
file->Read(sizeof(scratch), sizeof(scratch), &result, scratch)));
EXPECT_EQ("6789", result);
}
TEST(GcsFileSystemTest, NewRandomAccessFile_Buffered_Errors) {
std::vector<HttpRequest*> requests({
new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 0-9\n"
"Timeouts: 5 1 20\n",
"Server Not", errors::Unavailable("important HTTP error 308"),
nullptr, {}, 308),
new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 6-15\n"
"Timeouts: 5 1 20\n",
"123"),
});
GcsFileSystem fs(
std::unique_ptr<AuthProvider>(new FakeAuthProvider),
std::unique_ptr<HttpRequest::Factory>(
new FakeHttpRequestFactory(&requests)),
std::unique_ptr<ZoneProvider>(new FakeZoneProvider), 10 ,
0 , 0 , 0 ,
0 , 0 ,
0 , kTestRetryConfig,
kTestTimeoutConfig, *kAllowedLocationsDefault,
nullptr , false );
std::unique_ptr<RandomAccessFile> file;
TF_EXPECT_OK(
fs.NewRandomAccessFile("gs:
StringPiece filename;
TF_EXPECT_OK(file->Name(&filename));
EXPECT_EQ(filename, "gs:
char scratch[6];
StringPiece result;
EXPECT_TRUE(
errors::IsUnavailable(file->Read(0, sizeof(scratch), &result, scratch)));
EXPECT_EQ("", result);
EXPECT_TRUE(errors::IsOutOfRange(
file->Read(sizeof(scratch), sizeof(scratch), &result, scratch)));
EXPECT_EQ("123", result);
}
TEST(GcsFileSystemTest, NewRandomAccessFile_Buffered_ReadAtEOF) {
std::vector<HttpRequest*> requests(
{new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 0-9\n"
"Timeouts: 5 1 20\n",
"0123456789"),
new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 10-19\n"
"Timeouts: 5 1 20\n",
"")});
GcsFileSystem fs(
std::unique_ptr<AuthProvider>(new FakeAuthProvider),
std::unique_ptr<HttpRequest::Factory>(
new FakeHttpRequestFactory(&requests)),
std::unique_ptr<ZoneProvider>(new FakeZoneProvider), 10 ,
0 , 0 , 0 ,
0 , 0 ,
0 , kTestRetryConfig,
kTestTimeoutConfig, *kAllowedLocationsDefault,
nullptr , false );
std::unique_ptr<RandomAccessFile> file;
TF_EXPECT_OK(
fs.NewRandomAccessFile("gs:
StringPiece filename;
TF_EXPECT_OK(file->Name(&filename));
EXPECT_EQ(filename, "gs:
char scratch[10];
StringPiece result;
TF_EXPECT_OK(file->Read(0, sizeof(scratch), &result, scratch));
EXPECT_EQ("0123456789", result);
EXPECT_TRUE(errors::IsOutOfRange(
file->Read(sizeof(scratch), sizeof(scratch), &result, scratch)));
EXPECT_EQ("", result);
}
TEST(GcsFileSystemTest, NewRandomAccessFile_Buffered_CachedOutOfRange) {
std::vector<HttpRequest*> requests({new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 0-9\n"
"Timeouts: 5 1 20\n",
"012345678")});
GcsFileSystem fs(
std::unique_ptr<AuthProvider>(new FakeAuthProvider),
std::unique_ptr<HttpRequest::Factory>(
new FakeHttpRequestFactory(&requests)),
std::unique_ptr<ZoneProvider>(new FakeZoneProvider), 10 ,
0 , 0 , 0 ,
0 , 0 ,
0 , kTestRetryConfig,
kTestTimeoutConfig, *kAllowedLocationsDefault,
nullptr , false );
std::unique_ptr<RandomAccessFile> file;
TF_EXPECT_OK(
fs.NewRandomAccessFile("gs:
StringPiece filename;
TF_EXPECT_OK(file->Name(&filename));
EXPECT_EQ(filename, "gs:
char scratch[5];
StringPiece result;
TF_EXPECT_OK(file->Read(0, sizeof(scratch), &result, scratch));
EXPECT_EQ("01234", result);
TF_EXPECT_OK(file->Read(4, sizeof(scratch), &result, scratch));
EXPECT_EQ("45678", result);
EXPECT_TRUE(
errors::IsOutOfRange(file->Read(5, sizeof(scratch), &result, scratch)));
EXPECT_EQ("5678", result);
}
TEST(GcsFileSystemTest, NewRandomAccessFile_Buffered_CachedNotSequential) {
std::vector<HttpRequest*> requests(
{new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 1-10\n"
"Timeouts: 5 1 20\n",
"12345678"),
new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 0-9\n"
"Timeouts: 5 1 20\n",
"012345678")});
GcsFileSystem fs(
std::unique_ptr<AuthProvider>(new FakeAuthProvider),
std::unique_ptr<HttpRequest::Factory>(
new FakeHttpRequestFactory(&requests)),
std::unique_ptr<ZoneProvider>(new FakeZoneProvider), 10 ,
0 , 0 , 0 ,
0 , 0 ,
0 , kTestRetryConfig,
kTestTimeoutConfig, *kAllowedLocationsDefault,
nullptr , false );
std::unique_ptr<RandomAccessFile> file;
TF_EXPECT_OK(
fs.NewRandomAccessFile("gs:
StringPiece filename;
TF_EXPECT_OK(file->Name(&filename));
EXPECT_EQ(filename, "gs:
char scratch[5];
StringPiece result;
TF_EXPECT_OK(file->Read(1, sizeof(scratch), &result, scratch));
EXPECT_EQ("12345", result);
TF_EXPECT_OK(file->Read(0, sizeof(scratch), &result, scratch));
EXPECT_EQ("01234", result);
}
TEST(GcsFileSystemTest, NewRandomAccessFile_Buffered_Growing) {
std::vector<HttpRequest*> requests(
{new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 0-9\n"
"Timeouts: 5 1 20\n",
"012345678"),
new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 9-18\n"
"Timeouts: 5 1 20\n",
"9")});
GcsFileSystem fs(
std::unique_ptr<AuthProvider>(new FakeAuthProvider),
std::unique_ptr<HttpRequest::Factory>(
new FakeHttpRequestFactory(&requests)),
std::unique_ptr<ZoneProvider>(new FakeZoneProvider), 10 ,
0 , 0 , 0 ,
0 , 0 ,
0 , kTestRetryConfig,
kTestTimeoutConfig, *kAllowedLocationsDefault,
nullptr , false );
std::unique_ptr<RandomAccessFile> file;
TF_EXPECT_OK(
fs.NewRandomAccessFile("gs:
StringPiece filename;
TF_EXPECT_OK(file->Name(&filename));
EXPECT_EQ(filename, "gs:
char scratch[10];
StringPiece result;
EXPECT_TRUE(
errors::IsOutOfRange(file->Read(0, sizeof(scratch), &result, scratch)));
EXPECT_EQ("012345678", result);
TF_EXPECT_OK(file->Read(0, sizeof(scratch), &result, scratch));
EXPECT_EQ("0123456789", result);
}
TEST(GcsFileSystemTest, NewRandomAccessFile_Buffered_ReadBackwards) {
std::vector<HttpRequest*> requests(
{new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 5-14\n"
"Timeouts: 5 1 20\n",
"56789"),
new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 0-9\n"
"Timeouts: 5 1 20\n",
"0123456789")});
GcsFileSystem fs(
std::unique_ptr<AuthProvider>(new FakeAuthProvider),
std::unique_ptr<HttpRequest::Factory>(
new FakeHttpRequestFactory(&requests)),
std::unique_ptr<ZoneProvider>(new FakeZoneProvider), 10 ,
0 , 0 , 0 ,
0 , 0 ,
0 , kTestRetryConfig,
kTestTimeoutConfig, *kAllowedLocationsDefault,
nullptr , false );
std::unique_ptr<RandomAccessFile> file;
TF_EXPECT_OK(
fs.NewRandomAccessFile("gs:
StringPiece filename;
TF_EXPECT_OK(file->Name(&filename));
EXPECT_EQ(filename, "gs:
char scratch[10];
StringPiece result;
EXPECT_TRUE(
errors::IsOutOfRange(file->Read(5, sizeof(scratch), &result, scratch)));
EXPECT_EQ("56789", result);
TF_EXPECT_OK(file->Read(0, sizeof(scratch), &result, scratch));
EXPECT_EQ("0123456789", result);
}
TEST(GcsFileSystemTest,
NewRandomAccessFile_WithLocationConstraintInSameLocation) {
std::vector<HttpRequest*> requests({new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Timeouts: 5 1 10\n",
R"(
{
"location":"US-EAST1"
})")});
GcsFileSystem fs(
std::unique_ptr<AuthProvider>(new FakeAuthProvider),
std::unique_ptr<HttpRequest::Factory>(
new FakeHttpRequestFactory(&requests)),
std::unique_ptr<ZoneProvider>(new FakeZoneProvider), 0 ,
0 , 0 , 0 ,
0 , 0 ,
0 , kTestRetryConfig,
kTestTimeoutConfig, *kAllowedLocationsAuto,
nullptr , false );
std::unique_ptr<RandomAccessFile> file;
TF_EXPECT_OK(
fs.NewRandomAccessFile("gs:
}
TEST(GcsFileSystemTest, NewRandomAccessFile_WithLocationConstraintCaching) {
std::vector<HttpRequest*> requests(
{new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Timeouts: 5 1 10\n",
R"(
{
"location":"US-EAST1"
})"),
new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Timeouts: 5 1 10\n",
R"(
{
"location":"US-EAST1"
})"),
new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Timeouts: 5 1 10\n",
R"(
{
"location":"US-EAST1"
})")});
GcsFileSystem fs(
std::unique_ptr<AuthProvider>(new FakeAuthProvider),
std::unique_ptr<HttpRequest::Factory>(
new FakeHttpRequestFactory(&requests)),
std::unique_ptr<ZoneProvider>(new FakeZoneProvider), 0 ,
0 , 0 , 0 ,
0 , 0 ,
0 , kTestRetryConfig,
kTestTimeoutConfig, *kAllowedLocationsAuto,
nullptr , false );
std::unique_ptr<RandomAccessFile> file;
string bucket = "gs:
string another_bucket = "gs:
TF_EXPECT_OK(fs.NewRandomAccessFile(bucket, nullptr, &file));
TF_EXPECT_OK(fs.NewRandomAccessFile(bucket, nullptr, &file));
TF_EXPECT_OK(fs.NewRandomAccessFile(another_bucket, nullptr, &file));
TF_EXPECT_OK(fs.NewRandomAccessFile(bucket, nullptr, &file));
TF_EXPECT_OK(fs.NewRandomAccessFile(another_bucket, nullptr, &file));
fs.FlushCaches(nullptr);
TF_EXPECT_OK(fs.NewRandomAccessFile(bucket, nullptr, &file));
}
TEST(GcsFileSystemTest,
NewRandomAccessFile_WithLocationConstraintInDifferentLocation) {
std::vector<HttpRequest*> requests({new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Timeouts: 5 1 10\n",
R"(
{
"location":"BARFOO"
})")});
GcsFileSystem fs(
std::unique_ptr<AuthProvider>(new FakeAuthProvider),
std::unique_ptr<HttpRequest::Factory>(
new FakeHttpRequestFactory(&requests)),
std::unique_ptr<ZoneProvider>(new FakeZoneProvider), 0 ,
0 , 0 , 0 ,
0 , 0 ,
0 , kTestRetryConfig,
kTestTimeoutConfig, *kAllowedLocationsAuto,
nullptr , false );
std::unique_ptr<RandomAccessFile> file;
EXPECT_EQ(
errors::FailedPrecondition(
"Bucket 'bucket' is in 'barfoo' location, allowed locations "
"are: (us-east1)."),
fs.NewRandomAccessFile("gs:
}
TEST(GcsFileSystemTest, NewRandomAccessFile_NoBlockCache_DifferentN) {
std::vector<HttpRequest*> requests(
{new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 0-2\n"
"Timeouts: 5 1 20\n",
"012"),
new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 3-12\n"
"Timeouts: 5 1 20\n",
"3456789")});
GcsFileSystem fs(
std::unique_ptr<AuthProvider>(new FakeAuthProvider),
std::unique_ptr<HttpRequest::Factory>(
new FakeHttpRequestFactory(&requests)),
std::unique_ptr<ZoneProvider>(new FakeZoneProvider), 0 ,
0 , 0 , 0 ,
0 , 0 ,
0 , kTestRetryConfig,
kTestTimeoutConfig, *kAllowedLocationsDefault,
nullptr , false );
std::unique_ptr<RandomAccessFile> file;
TF_EXPECT_OK(
fs.NewRandomAccessFile("gs:
char small_scratch[3];
StringPiece result;
TF_EXPECT_OK(file->Read(0, sizeof(small_scratch), &result, small_scratch));
EXPECT_EQ("012", result);
char large_scratch[10];
EXPECT_TRUE(errors::IsOutOfRange(file->Read(
sizeof(small_scratch), sizeof(large_scratch), &result, large_scratch)));
EXPECT_EQ("3456789", result);
}
TEST(GcsFileSystemTest, NewRandomAccessFile_WithBlockCache) {
std::vector<HttpRequest*> requests(
{new FakeHttpRequest(
"Uri: https:
"random_access.txt?fields=size%2Cgeneration%2Cupdated\n"
"Auth Token: fake_token\n"
"Timeouts: 5 1 10\n",
strings::StrCat("{\"size\": \"15\",\"generation\": \"1\","
"\"updated\": \"2016-04-29T23:15:24.896Z\"}")),
new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 0-8\n"
"Timeouts: 5 1 20\n",
"012345678"),
new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 9-17\n"
"Timeouts: 5 1 20\n",
"9abcde"),
new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 18-26\n"
"Timeouts: 5 1 20\n",
"")});
GcsFileSystem fs(
std::unique_ptr<AuthProvider>(new FakeAuthProvider),
std::unique_ptr<HttpRequest::Factory>(
new FakeHttpRequestFactory(&requests)),
std::unique_ptr<ZoneProvider>(new FakeZoneProvider), 9 ,
18 , 0 , 3600 ,
0 , 0 ,
0 , kTestRetryConfig,
kTestTimeoutConfig, *kAllowedLocationsDefault,
nullptr , false );
char scratch[100];
StringPiece result;
{
std::unique_ptr<RandomAccessFile> file;
TF_EXPECT_OK(fs.NewRandomAccessFile("gs:
nullptr, &file));
scratch[5] = 'x';
TF_EXPECT_OK(file->Read(0, 4, &result, scratch));
EXPECT_EQ("0123", result);
EXPECT_EQ(scratch[5], 'x');
TF_EXPECT_OK(file->Read(4, 4, &result, scratch));
EXPECT_EQ("4567", result);
TF_EXPECT_OK(file->Read(6, 5, &result, scratch));
EXPECT_EQ("6789a", result);
EXPECT_TRUE(errors::IsOutOfRange(file->Read(6, 10, &result, scratch)));
EXPECT_EQ("6789abcde", result);
EXPECT_TRUE(errors::IsOutOfRange(file->Read(20, 10, &result, scratch)));
EXPECT_TRUE(result.empty());
TF_EXPECT_OK(file->Read(0, 4, &result, scratch));
}
EXPECT_EQ("0123", result);
}
TEST(GcsFileSystemTest, NewRandomAccessFile_WithBlockCache_Flush) {
std::vector<HttpRequest*> requests(
{new FakeHttpRequest(
"Uri: https:
"random_access.txt?fields=size%2Cgeneration%2Cupdated\n"
"Auth Token: fake_token\n"
"Timeouts: 5 1 10\n",
strings::StrCat("{\"size\": \"15\",\"generation\": \"1\","
"\"updated\": \"2016-04-29T23:15:24.896Z\"}")),
new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 0-8\n"
"Timeouts: 5 1 20\n",
"012345678"),
new FakeHttpRequest(
"Uri: https:
"random_access.txt?fields=size%2Cgeneration%2Cupdated\n"
"Auth Token: fake_token\n"
"Timeouts: 5 1 10\n",
strings::StrCat("{\"size\": \"15\",\"generation\": \"1\","
"\"updated\": \"2016-04-29T23:15:24.896Z\"}")),
new FakeHttpRequest(
"Uri: https:
"Auth Token: fake_token\n"
"Range: 0-8\n"
"Timeouts: 5 1 20\n",
"012345678")});
GcsFileSystem fs(
std::unique_ptr<AuthProvider>(new FakeAuthProvider),
std::unique_ptr<HttpRequest::Factory>(
new FakeHttpRequestFactory(&requests)),
std::unique_ptr<ZoneProvider>(new FakeZoneProvider), 9 ,
18 , 0 , 3600 ,
0 , 0 ,
0 , kTestRetryConfig,
kTestTimeoutConfig, *kAllowedLocationsDefault,
nullptr , false );
char scratch[100];
StringPiece result;
std::unique_ptr<RandomAccessFile> file;
TF_EXPECT_OK(
fs.NewRandomAccessFile("gs:
scratch[5] = 'x';
TF_EXPECT_OK(file->Read(0, 4, &result, scratch));
EXPECT_EQ("0123", result);
EXPECT_EQ(scratch[5], 'x');
fs.FlushCaches(nullptr);
TF_EXPECT_OK(file->Read(4, 4, &result, scratch));
EXPECT_EQ("4567", result);
}
TEST(GcsFileSystemTest, NewRandomAccessFile_WithBlockCache_MaxStaleness) {
std::vector<HttpRequest*> requests(
{new FakeHttpRequest(
"Uri: https:
"object?fields=size%2Cgeneration%2Cupdated\n"
"Auth Token: fake_token\n"
"Timeouts: 5 1 10\n",
strings::StrCat("{\"size\": \"16\",\"generation\": \"1\","
"\"updated\": \"2016-04-29T23:15:24.896Z\"}")),
new FakeHttpRequest("Uri: https:
"Auth Token: fake_token\n"
"Range: 0-7\n"
"Timeouts: 5 1 20\n",
"01234567"),
new FakeHttpRequest("Uri: https:
"Auth Token: fake_token\n"
"Range: 8-15\n"
"Timeouts: 5 1 20\n",
"89abcdef")});
GcsFileSystem fs(
std::unique_ptr<AuthProvider>(new FakeAuthProvider),
std::unique_ptr<HttpRequest::Factory>(
new FakeHttpRequestFactory(&requests)),
std::unique_ptr<ZoneProvider>(new FakeZoneProvider), 8 ,
16 , 3600 ,
3600 , 0 ,
0 ,
0 , kTestRetryConfig,
kTestTimeoutConfig, *kAllowedLocationsDefault,
nullptr , false );
char scratch[100];
StringPiece result;
for (int i = 0; i < 10; i++) {
std::unique_ptr<RandomAccessFile> file1;
std::unique_ptr<RandomAccessFile> file2;
TF_EXPECT_OK(fs.NewRandomAccessFile("gs:
TF_EXPECT_OK(fs.NewRandomAccessFile("gs:
TF_EXPECT_OK(file1->Read(0, 8, &result, scratch));
EXPECT_EQ("01234567", result);
TF_EXPECT_OK(file2->Read(0, 8, &result, scratch));
EXPECT_EQ("01234567", result);
TF_EXPECT_OK(file2->Read(8, 8, &result, scratch));
EXPECT_EQ("89abcdef", result);
TF_EXPECT_OK(file1->Read(8, 8, &result, scratch));
EXPECT_EQ("89abcdef", result);
}
}
TEST(GcsFileSystemTest,
NewRandomAccessFile_WithBlockCache_FileSignatureChanges) {
std::vector<HttpRequest*> requests(
{new FakeHttpRequest(
"Uri: https:
"random_access.txt?fields=size%2Cgeneration%2Cupdated\n"
"Auth Token: fake_token\n"
"Timeouts: 5 1 10\n",
strings::StrCat("{\"size\": \"5\",\"generation\": \"1\","
"\"updated\": \"2016-04-29T23:15:24.896Z\"}")),
new FakeHttpR |
2,611 | cpp | google/tsl | gcs_dns_cache | tsl/platform/cloud/gcs_dns_cache.cc | tsl/platform/cloud/gcs_dns_cache_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_CLOUD_GCS_DNS_CACHE_H_
#define TENSORFLOW_TSL_PLATFORM_CLOUD_GCS_DNS_CACHE_H_
#include <random>
#include "tsl/platform/cloud/http_request.h"
#include "tsl/platform/env.h"
namespace tsl {
const int64_t kDefaultRefreshRateSecs = 60;
class GcsDnsCache {
public:
GcsDnsCache() : GcsDnsCache(kDefaultRefreshRateSecs) {}
GcsDnsCache(int64_t refresh_rate_secs)
: GcsDnsCache(Env::Default(), refresh_rate_secs) {}
GcsDnsCache(Env* env, int64_t refresh_rate_secs);
~GcsDnsCache() {
mutex_lock l(mu_);
cancelled_ = true;
cond_var_.notify_one();
}
void AnnotateRequest(HttpRequest* request);
private:
static std::vector<string> ResolveName(const string& name);
static std::vector<std::vector<string>> ResolveNames(
const std::vector<string>& names);
void WorkerThread();
friend class GcsDnsCacheTest;
mutex mu_;
Env* env_;
condition_variable cond_var_;
std::default_random_engine random_ TF_GUARDED_BY(mu_);
bool started_ TF_GUARDED_BY(mu_) = false;
bool cancelled_ TF_GUARDED_BY(mu_) = false;
std::unique_ptr<Thread> worker_ TF_GUARDED_BY(mu_);
const int64_t refresh_rate_secs_;
std::vector<std::vector<string>> addresses_ TF_GUARDED_BY(mu_);
};
}
#endif
#include "tsl/platform/cloud/gcs_dns_cache.h"
#include <cstring>
#include "absl/status/status.h"
#include "absl/strings/str_cat.h"
#include "tsl/platform/errors.h"
#include "tsl/platform/retrying_utils.h"
#include "tsl/platform/status.h"
#ifndef _WIN32
#include <arpa/inet.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/socket.h>
#else
#include <Windows.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#endif
#include <sys/types.h>
namespace tsl {
namespace {
const std::vector<string>& kCachedDomainNames =
*new std::vector<string>{"www.googleapis.com", "storage.googleapis.com"};
inline void print_getaddrinfo_error(const string& name, Status return_status) {
LOG(ERROR) << "Error resolving " << name << ": " << return_status;
}
template <typename T>
const T& SelectRandomItemUniform(std::default_random_engine* random,
const std::vector<T>& items) {
CHECK_GT(items.size(), 0);
std::uniform_int_distribution<size_t> distribution(0u, items.size() - 1u);
size_t choice_index = distribution(*random);
return items[choice_index];
}
}
GcsDnsCache::GcsDnsCache(Env* env, int64_t refresh_rate_secs)
: env_(env), refresh_rate_secs_(refresh_rate_secs) {}
void GcsDnsCache::AnnotateRequest(HttpRequest* request) {
mutex_lock l(mu_);
if (!started_) {
VLOG(1) << "Starting GCS DNS cache.";
DCHECK(!worker_) << "Worker thread already exists!";
addresses_ = ResolveNames(kCachedDomainNames);
worker_.reset(env_->StartThread({}, "gcs_dns_worker",
[this]() { return WorkerThread(); }));
started_ = true;
}
CHECK_EQ(kCachedDomainNames.size(), addresses_.size());
for (size_t i = 0; i < kCachedDomainNames.size(); ++i) {
const string& name = kCachedDomainNames[i];
const std::vector<string>& addresses = addresses_[i];
if (!addresses.empty()) {
const string& chosen_address =
SelectRandomItemUniform(&random_, addresses);
request->AddResolveOverride(name, 443, chosen_address);
VLOG(1) << "Annotated DNS mapping: " << name << " --> " << chosen_address;
} else {
LOG(WARNING) << "No IP addresses available for " << name;
}
}
}
std::vector<string> GcsDnsCache::ResolveName(const string& name) {
VLOG(1) << "Resolving DNS name: " << name;
addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
addrinfo* result = nullptr;
RetryConfig retryConfig(
5000,
50 * 1000 * 5000,
5);
const Status getaddrinfo_status = RetryingUtils::CallWithRetries(
[&name, &hints, &result]() {
int return_code = getaddrinfo(name.c_str(), nullptr, &hints, &result);
absl::Status return_status;
switch (return_code) {
case 0:
return_status = OkStatus();
break;
#ifndef _WIN32
case EAI_ADDRFAMILY:
case EAI_SERVICE:
case EAI_SOCKTYPE:
case EAI_NONAME:
return_status = absl::FailedPreconditionError(
absl::StrCat("System in invalid state for getaddrinfo call: ",
gai_strerror(return_code)));
break;
case EAI_AGAIN:
case EAI_NODATA:
return_status = absl::UnavailableError(absl::StrCat(
"Resolving ", name, " is temporarily unavailable"));
break;
case EAI_BADFLAGS:
case EAI_FAMILY:
return_status = absl::InvalidArgumentError(absl::StrCat(
"Bad arguments for getaddrinfo: ", gai_strerror(return_code)));
break;
case EAI_FAIL:
return_status = absl::NotFoundError(
absl::StrCat("Permanent failure resolving ", name, ": ",
gai_strerror(return_code)));
break;
case EAI_MEMORY:
return_status = absl::ResourceExhaustedError("Out of memory");
break;
case EAI_SYSTEM:
default:
return_status = absl::UnknownError(strerror(return_code));
#else
case WSATYPE_NOT_FOUND:
case WSAESOCKTNOSUPPORT:
case WSAHOST_NOT_FOUND:
return_status = absl::FailedPreconditionError(
absl::StrCat("System in invalid state for getaddrinfo call: ",
gai_strerror(return_code)));
break;
case WSATRY_AGAIN:
return_status = absl::UnavailableError(absl::StrCat(
"Resolving ", name, " is temporarily unavailable"));
break;
case WSAEINVAL:
case WSAEAFNOSUPPORT:
return_status = absl::InvalidArgumentError(absl::StrCat(
"Bad arguments for getaddrinfo: ", gai_strerror(return_code)));
break;
case WSANO_RECOVERY:
return_status = absl::NotFoundError(
absl::StrCat("Permanent failure resolving ", name, ": ",
gai_strerror(return_code)));
break;
case WSA_NOT_ENOUGH_MEMORY:
return_status = absl::ResourceExhaustedError("Out of memory");
break;
default:
return_status = absl::UnknownError(strerror(return_code));
#endif
}
return Status(return_status);
},
retryConfig);
std::vector<string> output;
if (getaddrinfo_status.ok()) {
for (const addrinfo* i = result; i != nullptr; i = i->ai_next) {
if (i->ai_family != AF_INET || i->ai_addr->sa_family != AF_INET) {
LOG(WARNING) << "Non-IPv4 address returned. ai_family: " << i->ai_family
<< ". sa_family: " << i->ai_addr->sa_family << ".";
continue;
}
char buf[INET_ADDRSTRLEN];
void* address_ptr =
&(reinterpret_cast<sockaddr_in*>(i->ai_addr)->sin_addr);
const char* formatted = nullptr;
if ((formatted = inet_ntop(i->ai_addr->sa_family, address_ptr, buf,
INET_ADDRSTRLEN)) == nullptr) {
LOG(ERROR) << "Error converting response to IP address for " << name
<< ": " << strerror(errno);
} else {
output.emplace_back(buf);
VLOG(1) << "... address: " << buf;
}
}
} else {
print_getaddrinfo_error(name, getaddrinfo_status);
}
if (result != nullptr) {
freeaddrinfo(result);
}
return output;
}
std::vector<std::vector<string>> GcsDnsCache::ResolveNames(
const std::vector<string>& names) {
std::vector<std::vector<string>> all_addresses;
all_addresses.reserve(names.size());
for (const string& name : names) {
all_addresses.push_back(ResolveName(name));
}
return all_addresses;
}
void GcsDnsCache::WorkerThread() {
while (true) {
{
mutex_lock l(mu_);
if (cancelled_) return;
cond_var_.wait_for(l, std::chrono::seconds(refresh_rate_secs_));
if (cancelled_) return;
}
auto new_addresses = ResolveNames(kCachedDomainNames);
{
mutex_lock l(mu_);
addresses_.swap(new_addresses);
}
}
}
} | #include "tsl/platform/cloud/gcs_dns_cache.h"
#include "tsl/platform/str_util.h"
#include "tsl/platform/test.h"
namespace tsl {
class TestHttpRequest : public HttpRequest {
public:
void SetUri(const string& uri) override {}
void SetRange(uint64 start, uint64 end) override {}
void AddHeader(const string& name, const string& value) override {}
void AddResolveOverride(const string& hostname, int64_t port,
const string& ip_addr) override {
EXPECT_EQ(port, 443) << "Unexpected port set for hostname: " << hostname;
auto itr = resolve_overrides_.find(hostname);
EXPECT_EQ(itr, resolve_overrides_.end())
<< "Hostname " << hostname << "already in map: " << itr->second;
resolve_overrides_.insert(
std::map<string, string>::value_type(hostname, ip_addr));
}
void AddAuthBearerHeader(const string& auth_token) override {}
void SetRequestStats(HttpRequest::RequestStats* stats) override {}
void SetDeleteRequest() override {}
Status SetPutFromFile(const string& body_filepath, size_t offset) override {
return OkStatus();
}
void SetPutEmptyBody() override {}
void SetPostFromBuffer(const char* buffer, size_t size) override {}
void SetPostEmptyBody() override {}
void SetResultBuffer(std::vector<char>* out_buffer) override {}
void SetResultBufferDirect(char* buffer, size_t size) override {}
size_t GetResultBufferDirectBytesTransferred() override { return 0; }
string GetResponseHeader(const string& name) const override { return ""; }
uint64 GetResponseCode() const override { return 0; }
Status Send() override { return OkStatus(); }
string EscapeString(const string& str) override { return ""; }
void SetTimeouts(uint32 connection, uint32 inactivity,
uint32 total) override {}
std::map<string, string> resolve_overrides_;
};
class GcsDnsCacheTest : public ::testing::Test {
protected:
void ResolveNameTest() {
auto response = GcsDnsCache::ResolveName("www.googleapis.com");
EXPECT_LT(1, response.size()) << absl::StrJoin(response, ", ");
}
void AnnotateRequestTest() {
GcsDnsCache d;
{
mutex_lock l(d.mu_);
d.started_ = true;
d.addresses_ = {{"192.168.1.1"}, {"172.134.1.1"}};
}
TestHttpRequest req;
d.AnnotateRequest(&req);
EXPECT_EQ("192.168.1.1", req.resolve_overrides_["www.googleapis.com"]);
EXPECT_EQ("172.134.1.1", req.resolve_overrides_["storage.googleapis.com"]);
}
void SuccessfulCleanupTest() {
GcsDnsCache d;
TestHttpRequest req;
d.AnnotateRequest(&req);
}
};
TEST_F(GcsDnsCacheTest, AnnotateRequest) { AnnotateRequestTest(); }
TEST_F(GcsDnsCacheTest, SuccessfulCleanup) { SuccessfulCleanupTest(); }
} |
2,612 | cpp | google/tsl | compute_engine_metadata_client | tsl/platform/cloud/compute_engine_metadata_client.cc | tsl/platform/cloud/compute_engine_metadata_client_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_CLOUD_COMPUTE_ENGINE_METADATA_CLIENT_H_
#define TENSORFLOW_TSL_PLATFORM_CLOUD_COMPUTE_ENGINE_METADATA_CLIENT_H_
#include "tsl/platform/cloud/http_request.h"
#include "tsl/platform/retrying_utils.h"
#include "tsl/platform/status.h"
namespace tsl {
class ComputeEngineMetadataClient {
public:
explicit ComputeEngineMetadataClient(
std::shared_ptr<HttpRequest::Factory> http_request_factory,
const RetryConfig& config = RetryConfig(
10000,
1000000
));
virtual ~ComputeEngineMetadataClient() {}
virtual Status GetMetadata(const string& path,
std::vector<char>* response_buffer);
private:
std::shared_ptr<HttpRequest::Factory> http_request_factory_;
const RetryConfig retry_config_;
ComputeEngineMetadataClient(const ComputeEngineMetadataClient&) = delete;
void operator=(const ComputeEngineMetadataClient&) = delete;
};
}
#endif
#include "tsl/platform/cloud/compute_engine_metadata_client.h"
#include <cstdlib>
#include <utility>
#include "absl/strings/str_cat.h"
#include "tsl/platform/cloud/curl_http_request.h"
namespace tsl {
namespace {
constexpr char kGceMetadataHost[] = "GCE_METADATA_HOST";
constexpr char kGceMetadataBaseUrl[] =
"http:
}
ComputeEngineMetadataClient::ComputeEngineMetadataClient(
std::shared_ptr<HttpRequest::Factory> http_request_factory,
const RetryConfig& config)
: http_request_factory_(std::move(http_request_factory)),
retry_config_(config) {}
Status ComputeEngineMetadataClient::GetMetadata(
const string& path, std::vector<char>* response_buffer) {
const auto get_metadata_from_gce = [path, response_buffer, this]() {
string metadata_url;
const char* metadata_url_override = std::getenv(kGceMetadataHost);
if (metadata_url_override) {
metadata_url = absl::StrCat("http:
"/computeMetadata/v1/");
} else {
metadata_url = kGceMetadataBaseUrl;
}
std::unique_ptr<HttpRequest> request(http_request_factory_->Create());
request->SetUri(metadata_url + path);
request->AddHeader("Metadata-Flavor", "Google");
request->SetResultBuffer(response_buffer);
TF_RETURN_IF_ERROR(request->Send());
return OkStatus();
};
return RetryingUtils::CallWithRetries(get_metadata_from_gce, retry_config_);
}
} | #include "tsl/platform/cloud/compute_engine_metadata_client.h"
#include "tsl/platform/cloud/http_request_fake.h"
#include "tsl/platform/env.h"
#include "tsl/platform/test.h"
namespace tsl {
class ComputeEngineMetadataClientTest : public ::testing::Test {
protected:
void SetUp() override { ClearEnvVars(); }
void TearDown() override { ClearEnvVars(); }
void ClearEnvVars() { unsetenv("GCE_METADATA_HOST"); }
};
TEST_F(ComputeEngineMetadataClientTest, GetMetadata) {
const string example_response = "example response";
std::vector<HttpRequest*> requests({new FakeHttpRequest(
"Uri: http:
"/service-accounts/default/token\n"
"Header Metadata-Flavor: Google\n",
example_response)});
std::shared_ptr<HttpRequest::Factory> http_factory =
std::make_shared<FakeHttpRequestFactory>(&requests);
ComputeEngineMetadataClient client(http_factory,
RetryConfig(0 ));
std::vector<char> result;
TF_EXPECT_OK(
client.GetMetadata("instance/service-accounts/default/token", &result));
std::vector<char> expected(example_response.begin(), example_response.end());
EXPECT_EQ(expected, result);
}
TEST_F(ComputeEngineMetadataClientTest, GetCustomMetadataEndpoint) {
const string example_response = "example response";
setenv("GCE_METADATA_HOST", "foo.bar", 1);
std::vector<HttpRequest*> requests(
{new FakeHttpRequest("Uri: http:
"/service-accounts/default/token\n"
"Header Metadata-Flavor: Google\n",
example_response)});
std::shared_ptr<HttpRequest::Factory> http_factory =
std::make_shared<FakeHttpRequestFactory>(&requests);
ComputeEngineMetadataClient client(http_factory,
RetryConfig(0 ));
std::vector<char> result;
TF_EXPECT_OK(
client.GetMetadata("instance/service-accounts/default/token", &result));
std::vector<char> expected(example_response.begin(), example_response.end());
EXPECT_EQ(expected, result);
}
TEST_F(ComputeEngineMetadataClientTest, RetryOnFailure) {
const string example_response = "example response";
std::vector<HttpRequest*> requests(
{new FakeHttpRequest(
"Uri: http:
"/service-accounts/default/token\n"
"Header Metadata-Flavor: Google\n",
"", errors::Unavailable("503"), 503),
new FakeHttpRequest(
"Uri: http:
"/service-accounts/default/token\n"
"Header Metadata-Flavor: Google\n",
example_response)});
std::shared_ptr<HttpRequest::Factory> http_factory =
std::make_shared<FakeHttpRequestFactory>(&requests);
ComputeEngineMetadataClient client(http_factory,
RetryConfig(0 ));
std::vector<char> result;
TF_EXPECT_OK(
client.GetMetadata("instance/service-accounts/default/token", &result));
std::vector<char> expected(example_response.begin(), example_response.end());
EXPECT_EQ(expected, result);
}
} |
2,613 | cpp | google/tsl | oauth_client | tsl/platform/cloud/oauth_client.cc | tsl/platform/cloud/oauth_client_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_CLOUD_OAUTH_CLIENT_H_
#define TENSORFLOW_TSL_PLATFORM_CLOUD_OAUTH_CLIENT_H_
#include <memory>
#include "json/json.h"
#include "tsl/platform/cloud/http_request.h"
#include "tsl/platform/env.h"
#include "tsl/platform/status.h"
namespace tsl {
class OAuthClient {
public:
OAuthClient();
explicit OAuthClient(
std::unique_ptr<HttpRequest::Factory> http_request_factory, Env* env);
virtual ~OAuthClient() {}
virtual Status GetTokenFromServiceAccountJson(
Json::Value json, StringPiece oauth_server_uri, StringPiece scope,
string* token, uint64* expiration_timestamp_sec);
virtual Status GetTokenFromRefreshTokenJson(Json::Value json,
StringPiece oauth_server_uri,
string* token,
uint64* expiration_timestamp_sec);
virtual Status ParseOAuthResponse(StringPiece response,
uint64 request_timestamp_sec, string* token,
uint64* expiration_timestamp_sec);
private:
std::unique_ptr<HttpRequest::Factory> http_request_factory_;
Env* env_;
OAuthClient(const OAuthClient&) = delete;
void operator=(const OAuthClient&) = delete;
};
}
#endif
#include "tsl/platform/cloud/oauth_client.h"
#ifndef _WIN32
#include <pwd.h>
#include <sys/types.h>
#include <unistd.h>
#else
#include <sys/types.h>
#endif
#include <fstream>
#include <openssl/bio.h>
#include <openssl/evp.h>
#include <openssl/pem.h>
#include <openssl/rsa.h>
#include "tsl/platform/base64.h"
#include "tsl/platform/cloud/curl_http_request.h"
#include "tsl/platform/env.h"
#include "tsl/platform/errors.h"
namespace tsl {
namespace {
constexpr int kRequestedTokenLifetimeSec = 3600;
constexpr char kCryptoAlgorithm[] = "RS256";
constexpr char kJwtType[] = "JWT";
constexpr char kGrantType[] =
"urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Ajwt-bearer";
Status ReadJsonValue(const Json::Value& json, const string& name,
Json::Value* value) {
if (!value) {
return errors::FailedPrecondition("'value' cannot be nullptr.");
}
*value = json.get(name, Json::Value::null);
if (*value == Json::Value::null) {
return errors::FailedPrecondition(
strings::StrCat("Couldn't read a JSON value '", name, "'."));
}
return OkStatus();
}
Status ReadJsonString(const Json::Value& json, const string& name,
string* value) {
Json::Value json_value;
TF_RETURN_IF_ERROR(ReadJsonValue(json, name, &json_value));
if (!json_value.isString()) {
return errors::FailedPrecondition(
strings::StrCat("JSON value '", name, "' is not string."));
}
*value = json_value.asString();
return OkStatus();
}
Status ReadJsonInt(const Json::Value& json, const string& name,
int64_t* value) {
Json::Value json_value;
TF_RETURN_IF_ERROR(ReadJsonValue(json, name, &json_value));
if (!json_value.isIntegral()) {
return errors::FailedPrecondition(
strings::StrCat("JSON value '", name, "' is not integer."));
}
*value = json_value.asInt64();
return OkStatus();
}
Status CreateSignature(RSA* private_key, StringPiece to_sign,
string* signature) {
if (!private_key || !signature) {
return errors::FailedPrecondition(
"'private_key' and 'signature' cannot be nullptr.");
}
const auto md = EVP_sha256();
if (!md) {
return errors::Internal("Could not get a sha256 encryptor.");
}
std::unique_ptr<EVP_MD_CTX, std::function<void(EVP_MD_CTX*)>> md_ctx(
EVP_MD_CTX_create(), [](EVP_MD_CTX* ptr) { EVP_MD_CTX_destroy(ptr); });
if (!md_ctx) {
return errors::Internal("Could not create MD_CTX.");
}
std::unique_ptr<EVP_PKEY, std::function<void(EVP_PKEY*)>> key(
EVP_PKEY_new(), [](EVP_PKEY* ptr) { EVP_PKEY_free(ptr); });
EVP_PKEY_set1_RSA(key.get(), private_key);
if (EVP_DigestSignInit(md_ctx.get(), nullptr, md, nullptr, key.get()) != 1) {
return errors::Internal("DigestInit failed.");
}
if (EVP_DigestSignUpdate(md_ctx.get(), to_sign.data(), to_sign.size()) != 1) {
return errors::Internal("DigestUpdate failed.");
}
size_t sig_len = 0;
if (EVP_DigestSignFinal(md_ctx.get(), nullptr, &sig_len) != 1) {
return errors::Internal("DigestFinal (get signature length) failed.");
}
std::unique_ptr<unsigned char[]> sig(new unsigned char[sig_len]);
if (EVP_DigestSignFinal(md_ctx.get(), sig.get(), &sig_len) != 1) {
return errors::Internal("DigestFinal (signature compute) failed.");
}
return Base64Encode(StringPiece(reinterpret_cast<char*>(sig.get()), sig_len),
signature);
}
Status EncodeJwtClaim(StringPiece client_email, StringPiece scope,
StringPiece audience, uint64 request_timestamp_sec,
string* encoded) {
Json::Value root;
root["iss"] = Json::Value(client_email.data(),
client_email.data() + client_email.size());
root["scope"] = Json::Value(scope.data(), scope.data() + scope.size());
root["aud"] = Json::Value(audience.data(), audience.data() + audience.size());
const auto expiration_timestamp_sec =
request_timestamp_sec + kRequestedTokenLifetimeSec;
root["iat"] = Json::Value::UInt64(request_timestamp_sec);
root["exp"] = Json::Value::UInt64(expiration_timestamp_sec);
string claim = root.toStyledString();
return Base64Encode(claim, encoded);
}
Status EncodeJwtHeader(StringPiece key_id, string* encoded) {
Json::Value root;
root["alg"] = kCryptoAlgorithm;
root["typ"] = kJwtType;
root["kid"] = Json::Value(key_id.data(), key_id.data() + key_id.size());
const string header = root.toStyledString();
return Base64Encode(header, encoded);
}
}
OAuthClient::OAuthClient()
: OAuthClient(
std::unique_ptr<HttpRequest::Factory>(new CurlHttpRequest::Factory()),
Env::Default()) {}
OAuthClient::OAuthClient(
std::unique_ptr<HttpRequest::Factory> http_request_factory, Env* env)
: http_request_factory_(std::move(http_request_factory)), env_(env) {}
Status OAuthClient::GetTokenFromServiceAccountJson(
Json::Value json, StringPiece oauth_server_uri, StringPiece scope,
string* token, uint64* expiration_timestamp_sec) {
if (!token || !expiration_timestamp_sec) {
return errors::FailedPrecondition(
"'token' and 'expiration_timestamp_sec' cannot be nullptr.");
}
string private_key_serialized, private_key_id, client_id, client_email;
TF_RETURN_IF_ERROR(
ReadJsonString(json, "private_key", &private_key_serialized));
TF_RETURN_IF_ERROR(ReadJsonString(json, "private_key_id", &private_key_id));
TF_RETURN_IF_ERROR(ReadJsonString(json, "client_id", &client_id));
TF_RETURN_IF_ERROR(ReadJsonString(json, "client_email", &client_email));
std::unique_ptr<BIO, std::function<void(BIO*)>> bio(
BIO_new(BIO_s_mem()), [](BIO* ptr) { BIO_free_all(ptr); });
if (BIO_puts(bio.get(), private_key_serialized.c_str()) !=
static_cast<int>(private_key_serialized.size())) {
return errors::Internal("Could not load the private key.");
}
std::unique_ptr<RSA, std::function<void(RSA*)>> private_key(
PEM_read_bio_RSAPrivateKey(bio.get(), nullptr, nullptr, nullptr),
[](RSA* ptr) { RSA_free(ptr); });
if (!private_key) {
return errors::Internal("Could not deserialize the private key.");
}
const uint64 request_timestamp_sec = env_->NowSeconds();
string encoded_claim, encoded_header;
TF_RETURN_IF_ERROR(EncodeJwtHeader(private_key_id, &encoded_header));
TF_RETURN_IF_ERROR(EncodeJwtClaim(client_email, scope, oauth_server_uri,
request_timestamp_sec, &encoded_claim));
const string to_sign = encoded_header + "." + encoded_claim;
string signature;
TF_RETURN_IF_ERROR(CreateSignature(private_key.get(), to_sign, &signature));
const string jwt = to_sign + "." + signature;
const string request_body =
strings::StrCat("grant_type=", kGrantType, "&assertion=", jwt);
std::unique_ptr<HttpRequest> request(http_request_factory_->Create());
std::vector<char> response_buffer;
request->SetUri(string(oauth_server_uri));
request->SetPostFromBuffer(request_body.c_str(), request_body.size());
request->SetResultBuffer(&response_buffer);
TF_RETURN_IF_ERROR(request->Send());
StringPiece response =
StringPiece(response_buffer.data(), response_buffer.size());
TF_RETURN_IF_ERROR(ParseOAuthResponse(response, request_timestamp_sec, token,
expiration_timestamp_sec));
return OkStatus();
}
Status OAuthClient::GetTokenFromRefreshTokenJson(
Json::Value json, StringPiece oauth_server_uri, string* token,
uint64* expiration_timestamp_sec) {
if (!token || !expiration_timestamp_sec) {
return errors::FailedPrecondition(
"'token' and 'expiration_timestamp_sec' cannot be nullptr.");
}
string client_id, client_secret, refresh_token;
TF_RETURN_IF_ERROR(ReadJsonString(json, "client_id", &client_id));
TF_RETURN_IF_ERROR(ReadJsonString(json, "client_secret", &client_secret));
TF_RETURN_IF_ERROR(ReadJsonString(json, "refresh_token", &refresh_token));
const auto request_body = strings::StrCat(
"client_id=", client_id, "&client_secret=", client_secret,
"&refresh_token=", refresh_token, "&grant_type=refresh_token");
const uint64 request_timestamp_sec = env_->NowSeconds();
std::unique_ptr<HttpRequest> request(http_request_factory_->Create());
std::vector<char> response_buffer;
request->SetUri(string(oauth_server_uri));
request->SetPostFromBuffer(request_body.c_str(), request_body.size());
request->SetResultBuffer(&response_buffer);
TF_RETURN_IF_ERROR(request->Send());
StringPiece response =
StringPiece(response_buffer.data(), response_buffer.size());
TF_RETURN_IF_ERROR(ParseOAuthResponse(response, request_timestamp_sec, token,
expiration_timestamp_sec));
return OkStatus();
}
Status OAuthClient::ParseOAuthResponse(StringPiece response,
uint64 request_timestamp_sec,
string* token,
uint64* expiration_timestamp_sec) {
if (!token || !expiration_timestamp_sec) {
return errors::FailedPrecondition(
"'token' and 'expiration_timestamp_sec' cannot be nullptr.");
}
Json::Value root;
Json::Reader reader;
if (!reader.parse(response.data(), response.data() + response.size(), root)) {
return errors::Internal("Couldn't parse JSON response from OAuth server.");
}
string token_type;
TF_RETURN_IF_ERROR(ReadJsonString(root, "token_type", &token_type));
if (token_type != "Bearer") {
return errors::FailedPrecondition("Unexpected Oauth token type: " +
token_type);
}
int64_t expires_in = 0;
TF_RETURN_IF_ERROR(ReadJsonInt(root, "expires_in", &expires_in));
*expiration_timestamp_sec = request_timestamp_sec + expires_in;
TF_RETURN_IF_ERROR(ReadJsonString(root, "access_token", token));
return OkStatus();
}
} | #include "tsl/platform/cloud/oauth_client.h"
#include <fstream>
#include <openssl/bio.h>
#include <openssl/evp.h>
#include <openssl/pem.h>
#include "tsl/lib/core/status_test_util.h"
#include "tsl/platform/base64.h"
#include "tsl/platform/cloud/http_request_fake.h"
#include "tsl/platform/env.h"
#include "tsl/platform/path.h"
#include "tsl/platform/scanner.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace {
string TestData() {
return io::JoinPath(testing::TslSrcRoot(), "platform", "cloud", "testdata");
}
constexpr char kTokenJson[] = R"(
{
"access_token":"WITH_FAKE_ACCESS_TOKEN_TEST_SHOULD_BE_HAPPY",
"expires_in":3920,
"token_type":"Bearer"
})";
class FakeEnv : public EnvWrapper {
public:
FakeEnv() : EnvWrapper(Env::Default()) {}
uint64 NowSeconds() const override { return now; }
uint64 now = 10000;
};
}
TEST(OAuthClientTest, ParseOAuthResponse) {
const uint64 request_timestamp = 100;
string token;
uint64 expiration_timestamp;
TF_EXPECT_OK(OAuthClient().ParseOAuthResponse(kTokenJson, request_timestamp,
&token, &expiration_timestamp));
EXPECT_EQ("WITH_FAKE_ACCESS_TOKEN_TEST_SHOULD_BE_HAPPY", token);
EXPECT_EQ(4020, expiration_timestamp);
}
TEST(OAuthClientTest, GetTokenFromRefreshTokenJson) {
const string credentials_json = R"(
{
"client_id": "test_client_id",
"client_secret": "@@@test_client_secret@@@",
"refresh_token": "test_refresh_token",
"type": "authorized_user"
})";
Json::Value json;
Json::Reader reader;
ASSERT_TRUE(reader.parse(credentials_json, json));
std::vector<HttpRequest*> requests({new FakeHttpRequest(
"Uri: https:
"Post body: client_id=test_client_id&"
"client_secret=@@@test_client_secret@@@&"
"refresh_token=test_refresh_token&grant_type=refresh_token\n",
kTokenJson)});
FakeEnv env;
OAuthClient client(std::unique_ptr<HttpRequest::Factory>(
new FakeHttpRequestFactory(&requests)),
&env);
string token;
uint64 expiration_timestamp;
TF_EXPECT_OK(client.GetTokenFromRefreshTokenJson(
json, "https:
&expiration_timestamp));
EXPECT_EQ("WITH_FAKE_ACCESS_TOKEN_TEST_SHOULD_BE_HAPPY", token);
EXPECT_EQ(13920, expiration_timestamp);
}
TEST(OAuthClientTest, GetTokenFromServiceAccountJson) {
std::ifstream credentials(
io::JoinPath(TestData(), "service_account_credentials.json"));
ASSERT_TRUE(credentials.is_open());
Json::Value json;
Json::Reader reader;
ASSERT_TRUE(reader.parse(credentials, json));
string post_body;
std::vector<HttpRequest*> requests(
{new FakeHttpRequest("Uri: https:
kTokenJson, &post_body)});
FakeEnv env;
OAuthClient client(std::unique_ptr<HttpRequest::Factory>(
new FakeHttpRequestFactory(&requests)),
&env);
string token;
uint64 expiration_timestamp;
TF_EXPECT_OK(client.GetTokenFromServiceAccountJson(
json, "https:
"https:
EXPECT_EQ("WITH_FAKE_ACCESS_TOKEN_TEST_SHOULD_BE_HAPPY", token);
EXPECT_EQ(13920, expiration_timestamp);
StringPiece grant_type, assertion;
ASSERT_TRUE(strings::Scanner(post_body)
.OneLiteral("grant_type=")
.RestartCapture()
.ScanEscapedUntil('&')
.StopCapture()
.OneLiteral("&assertion=")
.GetResult(&assertion, &grant_type));
EXPECT_EQ("urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Ajwt-bearer",
grant_type);
int last_dot = assertion.rfind('.');
string header_dot_claim(assertion.substr(0, last_dot));
string signature_encoded(assertion.substr(last_dot + 1));
std::ifstream public_key_stream(
io::JoinPath(TestData(), "service_account_public_key.txt"));
string public_key_serialized(
(std::istreambuf_iterator<char>(public_key_stream)),
(std::istreambuf_iterator<char>()));
auto bio = BIO_new(BIO_s_mem());
RSA* public_key = nullptr;
EXPECT_EQ(public_key_serialized.size(),
BIO_puts(bio, public_key_serialized.c_str()));
public_key = PEM_read_bio_RSA_PUBKEY(bio, nullptr, nullptr, nullptr);
EXPECT_TRUE(public_key) << "Could not load the public key from testdata.";
string signature;
TF_EXPECT_OK(Base64Decode(signature_encoded, &signature));
const auto md = EVP_sha256();
auto md_ctx = EVP_MD_CTX_create();
auto key = EVP_PKEY_new();
EVP_PKEY_set1_RSA(key, public_key);
ASSERT_EQ(1, EVP_DigestVerifyInit(md_ctx, nullptr, md, nullptr, key));
ASSERT_EQ(1, EVP_DigestVerifyUpdate(md_ctx, header_dot_claim.c_str(),
header_dot_claim.size()));
ASSERT_EQ(1,
EVP_DigestVerifyFinal(
md_ctx,
const_cast<unsigned char*>(
reinterpret_cast<const unsigned char*>(signature.data())),
signature.size()));
EVP_PKEY_free(key);
EVP_MD_CTX_destroy(md_ctx);
RSA_free(public_key);
BIO_free_all(bio);
int dot = header_dot_claim.find_last_of('.');
string header_encoded = header_dot_claim.substr(0, dot);
string claim_encoded = header_dot_claim.substr(dot + 1);
string header, claim;
TF_EXPECT_OK(Base64Decode(header_encoded, &header));
TF_EXPECT_OK(Base64Decode(claim_encoded, &claim));
Json::Value header_json, claim_json;
EXPECT_TRUE(reader.parse(header, header_json));
EXPECT_EQ("RS256", header_json.get("alg", Json::Value::null).asString());
EXPECT_EQ("JWT", header_json.get("typ", Json::Value::null).asString());
EXPECT_EQ("fake_key_id",
header_json.get("kid", Json::Value::null).asString());
EXPECT_TRUE(reader.parse(claim, claim_json));
EXPECT_EQ("fake-test-project.iam.gserviceaccount.com",
claim_json.get("iss", Json::Value::null).asString());
EXPECT_EQ("https:
claim_json.get("scope", Json::Value::null).asString());
EXPECT_EQ("https:
claim_json.get("aud", Json::Value::null).asString());
EXPECT_EQ(10000, claim_json.get("iat", Json::Value::null).asInt64());
EXPECT_EQ(13600, claim_json.get("exp", Json::Value::null).asInt64());
}
} |
2,614 | cpp | google/tsl | compute_engine_zone_provider | tsl/platform/cloud/compute_engine_zone_provider.cc | tsl/platform/cloud/compute_engine_zone_provider_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_CLOUD_COMPUTE_ENGINE_ZONE_PROVIDER_H_
#define TENSORFLOW_TSL_PLATFORM_CLOUD_COMPUTE_ENGINE_ZONE_PROVIDER_H_
#include "tsl/platform/cloud/compute_engine_metadata_client.h"
#include "tsl/platform/cloud/zone_provider.h"
namespace tsl {
class ComputeEngineZoneProvider : public ZoneProvider {
public:
explicit ComputeEngineZoneProvider(
std::shared_ptr<ComputeEngineMetadataClient> google_metadata_client);
virtual ~ComputeEngineZoneProvider();
Status GetZone(string* zone) override;
private:
std::shared_ptr<ComputeEngineMetadataClient> google_metadata_client_;
string cached_zone;
ComputeEngineZoneProvider(const ComputeEngineZoneProvider&) = delete;
void operator=(const ComputeEngineZoneProvider&) = delete;
};
}
#endif
#include "tsl/platform/cloud/compute_engine_zone_provider.h"
#include <utility>
#include "tsl/platform/str_util.h"
namespace tsl {
namespace {
constexpr char kGceMetadataZonePath[] = "instance/zone";
}
ComputeEngineZoneProvider::ComputeEngineZoneProvider(
std::shared_ptr<ComputeEngineMetadataClient> google_metadata_client)
: google_metadata_client_(std::move(google_metadata_client)) {}
Status ComputeEngineZoneProvider::GetZone(string* zone) {
if (!cached_zone.empty()) {
*zone = cached_zone;
return OkStatus();
}
std::vector<char> response_buffer;
TF_RETURN_IF_ERROR(google_metadata_client_->GetMetadata(kGceMetadataZonePath,
&response_buffer));
StringPiece location(&response_buffer[0], response_buffer.size());
std::vector<string> elems = str_util::Split(location, "/");
if (elems.size() == 4) {
cached_zone = elems.back();
*zone = cached_zone;
} else {
LOG(ERROR) << "Failed to parse the zone name from location: "
<< string(location);
}
return OkStatus();
}
ComputeEngineZoneProvider::~ComputeEngineZoneProvider() {}
} | #include "tsl/platform/cloud/compute_engine_zone_provider.h"
#include "tsl/platform/cloud/http_request_fake.h"
#include "tsl/platform/test.h"
namespace tsl {
class ComputeEngineZoneProviderTest : public ::testing::Test {
protected:
void SetUp() override {}
void TearDown() override {}
};
TEST_F(ComputeEngineZoneProviderTest, GetZone) {
std::vector<HttpRequest*> requests({new FakeHttpRequest(
"Uri: http:
"Header Metadata-Flavor: Google\n",
"projects/123456789/zones/us-west1-b")});
auto httpRequestFactory = std::make_shared<FakeHttpRequestFactory>(&requests);
auto metadata_client = std::make_shared<ComputeEngineMetadataClient>(
httpRequestFactory, RetryConfig(0 ));
ComputeEngineZoneProvider provider(metadata_client);
string zone;
TF_EXPECT_OK(provider.GetZone(&zone));
EXPECT_EQ("us-west1-b", zone);
TF_EXPECT_OK(provider.GetZone(&zone));
}
TEST_F(ComputeEngineZoneProviderTest, InvalidZoneString) {
std::vector<HttpRequest*> requests({new FakeHttpRequest(
"Uri: http:
"Header Metadata-Flavor: Google\n",
"invalidresponse")});
auto httpRequestFactory = std::make_shared<FakeHttpRequestFactory>(&requests);
auto metadata_client = std::make_shared<ComputeEngineMetadataClient>(
httpRequestFactory, RetryConfig(0 ));
ComputeEngineZoneProvider provider(metadata_client);
string zone;
TF_EXPECT_OK(provider.GetZone(&zone));
EXPECT_EQ("", zone);
}
} |
2,615 | cpp | google/tsl | cpu_utils | tsl/platform/profile_utils/cpu_utils.cc | tsl/platform/profile_utils/cpu_utils_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_PROFILE_UTILS_CPU_UTILS_H_
#define TENSORFLOW_TSL_PLATFORM_PROFILE_UTILS_CPU_UTILS_H_
#include <chrono>
#include <memory>
#include "tsl/platform/macros.h"
#include "tsl/platform/profile_utils/i_cpu_utils_helper.h"
#include "tsl/platform/types.h"
#if defined(ARMV6) || defined(__ARM_ARCH_7A__)
#include <sys/time.h>
#endif
#if defined(_WIN32)
#include <intrin.h>
#endif
namespace tsl {
namespace profile_utils {
class CpuUtils {
public:
static constexpr int64_t INVALID_FREQUENCY = -1;
static constexpr uint64 DUMMY_CYCLE_CLOCK = 1;
static inline uint64 GetCurrentClockCycle() {
#if defined(__ANDROID__)
return GetCpuUtilsHelperSingletonInstance().GetCurrentClockCycle();
#elif defined(_WIN32)
return __rdtsc();
#elif defined(__x86_64__) || defined(__amd64__)
uint64_t high, low;
__asm__ volatile("rdtsc" : "=a"(low), "=d"(high));
return (high << 32) | low;
#elif defined(__aarch64__)
uint64_t virtual_timer_value;
asm volatile("mrs %0, cntvct_el0" : "=r"(virtual_timer_value));
return virtual_timer_value;
#elif defined(ARMV6) || defined(__ARM_ARCH_7A__)
uint32_t pmccntr;
uint32_t pmuseren;
uint32_t pmcntenset;
asm volatile("mrc p15, 0, %0, c9, c14, 0" : "=r"(pmuseren));
if (pmuseren & 1) {
asm volatile("mrc p15, 0, %0, c9, c12, 1" : "=r"(pmcntenset));
if (pmcntenset & 0x80000000ul) {
asm volatile("mrc p15, 0, %0, c9, c13, 0" : "=r"(pmccntr));
return static_cast<uint64>(pmccntr) * 64;
}
}
return DUMMY_CYCLE_CLOCK;
#elif defined(__powerpc64__) || defined(__ppc64__)
uint64 __t;
__asm__ __volatile__("mfspr %0,268" : "=r"(__t));
return __t;
#elif defined(__powerpc__) || defined(__ppc__)
uint64 upper, lower, tmp;
__asm__ volatile(
"0: \n"
"\tmftbu %0 \n"
"\tmftb %1 \n"
"\tmftbu %2 \n"
"\tcmpw %2,%0 \n"
"\tbne 0b \n"
: "=r"(upper), "=r"(lower), "=r"(tmp));
return ((static_cast<uint64>(upper) << 32) | lower);
#elif defined(__s390x__)
uint64 t;
__asm__ __volatile__("stckf %0" : "=Q"(t));
return t;
#else
return DUMMY_CYCLE_CLOCK;
#endif
}
#if (defined(__powerpc__) || \
defined(__ppc__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) || \
(defined(__s390x__))
static uint64 GetCycleCounterFrequency();
#else
static int64_t GetCycleCounterFrequency();
#endif
static double GetMicroSecPerClock();
static void ResetClockCycle();
static void EnableClockCycleProfiling();
static void DisableClockCycleProfiling();
static std::chrono::duration<double> ConvertClockCycleToTime(
const int64_t clock_cycle);
private:
class DefaultCpuUtilsHelper : public ICpuUtilsHelper {
public:
DefaultCpuUtilsHelper() = default;
void ResetClockCycle() final {}
uint64 GetCurrentClockCycle() final { return DUMMY_CYCLE_CLOCK; }
void EnableClockCycleProfiling() final {}
void DisableClockCycleProfiling() final {}
int64_t CalculateCpuFrequency() final { return INVALID_FREQUENCY; }
private:
DefaultCpuUtilsHelper(const DefaultCpuUtilsHelper&) = delete;
void operator=(const DefaultCpuUtilsHelper&) = delete;
};
static int64_t GetCycleCounterFrequencyImpl();
static ICpuUtilsHelper& GetCpuUtilsHelperSingletonInstance();
CpuUtils(const CpuUtils&) = delete;
void operator=(const CpuUtils&) = delete;
};
}
}
#endif
#include "tsl/platform/profile_utils/cpu_utils.h"
#include <fstream>
#include <limits>
#include <mutex>
#if defined(_WIN32)
#include <windows.h>
#endif
#if defined(__APPLE__)
#include <sys/sysctl.h>
#endif
#include "absl/base/call_once.h"
#include "tsl/platform/logging.h"
#include "tsl/platform/profile_utils/android_armv7a_cpu_utils_helper.h"
namespace tsl {
namespace profile_utils {
constexpr int64_t CpuUtils::INVALID_FREQUENCY;
static ICpuUtilsHelper* cpu_utils_helper_instance_ = nullptr;
#if (defined(__powerpc__) || \
defined(__ppc__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) || \
(defined(__s390x__))
uint64 CpuUtils::GetCycleCounterFrequency() {
static const uint64 cpu_frequency = GetCycleCounterFrequencyImpl();
return cpu_frequency;
}
#else
int64_t CpuUtils::GetCycleCounterFrequency() {
static const int64_t cpu_frequency = GetCycleCounterFrequencyImpl();
return cpu_frequency;
}
#endif
double CpuUtils::GetMicroSecPerClock() {
static const double micro_sec_per_clock =
(1000.0 * 1000.0) / static_cast<double>(GetCycleCounterFrequency());
return micro_sec_per_clock;
}
void CpuUtils::ResetClockCycle() {
GetCpuUtilsHelperSingletonInstance().ResetClockCycle();
}
void CpuUtils::EnableClockCycleProfiling() {
GetCpuUtilsHelperSingletonInstance().EnableClockCycleProfiling();
}
void CpuUtils::DisableClockCycleProfiling() {
GetCpuUtilsHelperSingletonInstance().DisableClockCycleProfiling();
}
std::chrono::duration<double> CpuUtils::ConvertClockCycleToTime(
const int64_t clock_cycle) {
return std::chrono::duration<double>(static_cast<double>(clock_cycle) /
GetCycleCounterFrequency());
}
int64_t CpuUtils::GetCycleCounterFrequencyImpl() {
#if defined(__ANDROID__)
return GetCpuUtilsHelperSingletonInstance().CalculateCpuFrequency();
#elif defined(__linux__)
std::ifstream cpuinfo("/proc/cpuinfo");
if (!cpuinfo) {
LOG(WARNING) << "Failed to open /proc/cpuinfo";
return INVALID_FREQUENCY;
}
string line;
while (std::getline(cpuinfo, line)) {
double cpu_freq = 0.0;
int retval = 0;
double freq_factor = 2.0;
#if (defined(__powerpc__) || \
defined(__ppc__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
retval = sscanf(line.c_str(), "clock : %lfMHz", &cpu_freq);
freq_factor = 1.0;
#elif defined(__s390x__)
retval = sscanf(line.c_str(), "bogomips per cpu: %lf", &cpu_freq);
#elif defined(__aarch64__)
retval = sscanf(line.c_str(), "BogoMIPS : %lf", &cpu_freq);
#else
retval = sscanf(line.c_str(), "bogomips : %lf", &cpu_freq);
#endif
if (retval > 0) {
const double freq_ghz = cpu_freq / 1000.0 / freq_factor;
if (retval != 1 || freq_ghz < 0.01) {
LOG(WARNING) << "Failed to get CPU frequency: " << freq_ghz << " GHz";
return INVALID_FREQUENCY;
}
const int64_t freq_n =
static_cast<int64_t>(freq_ghz * 1000.0 * 1000.0 * 1000.0);
VLOG(1) << "CPU Frequency: " << freq_n << " Hz";
return freq_n;
}
}
LOG(WARNING)
<< "Failed to find bogomips or clock in /proc/cpuinfo; cannot determine "
"CPU frequency";
return INVALID_FREQUENCY;
#elif defined(__APPLE__)
int64_t freq_hz = 0;
size_t freq_hz_size = sizeof(freq_hz);
int retval =
sysctlbyname("hw.cpufrequency_max", &freq_hz, &freq_hz_size, NULL, 0);
if (retval != 0 || freq_hz < 1e6) {
int64_t tbfrequency = 0;
size_t tbfrequency_size = sizeof(tbfrequency);
retval = sysctlbyname("hw.tbfrequency", &tbfrequency, &tbfrequency_size,
NULL, 0);
if (retval == 0) {
clockinfo clock_info;
size_t clock_info_size = sizeof(clock_info);
retval = sysctlbyname("kern.clockrate", &clock_info, &clock_info_size,
NULL, 0);
if (retval == 0) {
freq_hz = clock_info.hz * tbfrequency;
}
}
if (retval != 0 || freq_hz < 1e6) {
LOG(WARNING) << "Failed to get CPU frequency: " << freq_hz << " Hz";
return INVALID_FREQUENCY;
}
}
return freq_hz;
#elif defined(_WIN32)
LARGE_INTEGER freq;
QueryPerformanceFrequency(&freq);
return freq.QuadPart;
#else
return INVALID_FREQUENCY;
#endif
}
ICpuUtilsHelper& CpuUtils::GetCpuUtilsHelperSingletonInstance() {
static absl::once_flag flag;
absl::call_once(flag, []() {
if (cpu_utils_helper_instance_ != nullptr) {
LOG(FATAL) << "cpu_utils_helper_instance_ is already instantiated.";
}
#if defined(__ANDROID__) && (__ANDROID_API__ >= 21) && \
(defined(__ARM_ARCH_7A__) || defined(__aarch64__))
cpu_utils_helper_instance_ = new AndroidArmV7ACpuUtilsHelper();
#else
cpu_utils_helper_instance_ = new DefaultCpuUtilsHelper();
#endif
});
return *cpu_utils_helper_instance_;
}
}
} | #include "tsl/platform/profile_utils/cpu_utils.h"
#include "tsl/platform/logging.h"
#include "tsl/platform/profile_utils/clock_cycle_profiler.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace profile_utils {
static constexpr bool DBG = false;
class CpuUtilsTest : public ::testing::Test {
protected:
void SetUp() override { CpuUtils::EnableClockCycleProfiling(); }
};
TEST_F(CpuUtilsTest, SetUpTestCase) {}
TEST_F(CpuUtilsTest, TearDownTestCase) {}
TEST_F(CpuUtilsTest, CheckGetCurrentClockCycle) {
static constexpr int LOOP_COUNT = 10;
const uint64 start_clock_count = CpuUtils::GetCurrentClockCycle();
CHECK_GT(start_clock_count, 0);
uint64 prev_clock_count = start_clock_count;
for (int i = 0; i < LOOP_COUNT; ++i) {
const uint64 clock_count = CpuUtils::GetCurrentClockCycle();
CHECK_GE(clock_count, prev_clock_count);
prev_clock_count = clock_count;
}
const uint64 end_clock_count = CpuUtils::GetCurrentClockCycle();
if (DBG) {
LOG(INFO) << "start clock = " << start_clock_count;
LOG(INFO) << "end clock = " << end_clock_count;
LOG(INFO) << "average clock = "
<< ((end_clock_count - start_clock_count) / LOOP_COUNT);
}
}
TEST_F(CpuUtilsTest, CheckCycleCounterFrequency) {
#if (defined(__powerpc__) || \
defined(__ppc__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) || \
(defined(__s390x__))
const uint64 cpu_frequency = CpuUtils::GetCycleCounterFrequency();
CHECK_GT(cpu_frequency, 0);
CHECK_NE(cpu_frequency, unsigned(CpuUtils::INVALID_FREQUENCY));
#else
const int64_t cpu_frequency = CpuUtils::GetCycleCounterFrequency();
CHECK_GT(cpu_frequency, 0);
CHECK_NE(cpu_frequency, CpuUtils::INVALID_FREQUENCY);
#endif
if (DBG) {
LOG(INFO) << "Cpu frequency = " << cpu_frequency;
}
}
TEST_F(CpuUtilsTest, CheckMicroSecPerClock) {
const double micro_sec_per_clock = CpuUtils::GetMicroSecPerClock();
CHECK_GT(micro_sec_per_clock, 0.0);
if (DBG) {
LOG(INFO) << "Micro sec per clock = " << micro_sec_per_clock;
}
}
TEST_F(CpuUtilsTest, SimpleUsageOfClockCycleProfiler) {
static constexpr int LOOP_COUNT = 10;
ClockCycleProfiler prof;
for (int i = 0; i < LOOP_COUNT; ++i) {
prof.Start();
prof.Stop();
}
EXPECT_EQ(LOOP_COUNT, static_cast<int>(prof.GetCount() + 0.5));
if (DBG) {
prof.DumpStatistics("CpuUtilsTest");
}
}
}
} |
2,616 | cpp | google/tsl | net | tsl/platform/windows/net.cc | tsl/platform/net_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_NET_H_
#define TENSORFLOW_TSL_PLATFORM_NET_H_
namespace tsl {
namespace internal {
int PickUnusedPortOrDie();
}
}
#endif
#include "tsl/platform/net.h"
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <cerrno>
#include <cstdlib>
#include <cstring>
#include <random>
#include <unordered_set>
#include "tsl/platform/logging.h"
#include "tsl/platform/strcat.h"
#define MAX_EPHEMERAL_PORT 60999
#define MIN_EPHEMERAL_PORT 32768
namespace tsl {
namespace internal {
namespace {
bool IsPortAvailable(int* port, bool is_tcp) {
const int protocol = is_tcp ? IPPROTO_TCP : 0;
const int fd = socket(AF_INET, is_tcp ? SOCK_STREAM : SOCK_DGRAM, protocol);
struct sockaddr_in addr;
socklen_t addr_len = sizeof(addr);
int actual_port;
CHECK_GE(*port, 0);
CHECK_LE(*port, MAX_EPHEMERAL_PORT);
if (fd < 0) {
LOG(ERROR) << "socket() failed: " << strerror(errno);
return false;
}
int one = 1;
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)) < 0) {
LOG(ERROR) << "setsockopt() failed: " << strerror(errno);
if (close(fd) < 0) {
LOG(ERROR) << "close() failed: " << strerror(errno);
};
return false;
}
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = htons(static_cast<uint16_t>(*port));
if (bind(fd, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)) < 0) {
LOG(WARNING) << "bind(port=" << *port << ") failed: " << strerror(errno);
if (close(fd) < 0) {
LOG(ERROR) << "close() failed: " << strerror(errno);
};
return false;
}
if (getsockname(fd, reinterpret_cast<struct sockaddr*>(&addr), &addr_len) <
0) {
LOG(WARNING) << "getsockname() failed: " << strerror(errno);
if (close(fd) < 0) {
LOG(ERROR) << "close() failed: " << strerror(errno);
};
return false;
}
CHECK_LE(addr_len, sizeof(addr));
actual_port = ntohs(addr.sin_port);
CHECK_GT(actual_port, 0);
if (*port == 0) {
*port = actual_port;
} else {
CHECK_EQ(*port, actual_port);
}
if (close(fd) < 0) {
LOG(ERROR) << "close() failed: " << strerror(errno);
};
return true;
}
const int kNumRandomPortsToPick = 100;
const int kMaximumTrials = 1000;
}
int PickUnusedPortOrDie() {
static std::unordered_set<int> chosen_ports;
bool is_tcp = true;
int trial = 0;
std::default_random_engine rgen(std::random_device{}());
std::uniform_int_distribution<int> rdist(MIN_EPHEMERAL_PORT,
MAX_EPHEMERAL_PORT - 1);
while (true) {
int port;
trial++;
CHECK_LE(trial, kMaximumTrials)
<< "Failed to pick an unused port for testing.";
if (trial == 1) {
port = getpid() % (MAX_EPHEMERAL_PORT - MIN_EPHEMERAL_PORT) +
MIN_EPHEMERAL_PORT;
} else if (trial <= kNumRandomPortsToPick) {
port = rdist(rgen);
} else {
port = 0;
}
if (chosen_ports.find(port) != chosen_ports.end()) {
continue;
}
if (!IsPortAvailable(&port, is_tcp)) {
continue;
}
CHECK_GT(port, 0);
if (!IsPortAvailable(&port, !is_tcp)) {
is_tcp = !is_tcp;
continue;
}
chosen_ports.insert(port);
return port;
}
return 0;
}
}
} | #include "tsl/platform/net.h"
#include "tsl/platform/logging.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace internal {
TEST(Net, PickUnusedPortOrDie) {
int port0 = PickUnusedPortOrDie();
int port1 = PickUnusedPortOrDie();
CHECK_GE(port0, 0);
CHECK_LT(port0, 65536);
CHECK_GE(port1, 0);
CHECK_LT(port1, 65536);
CHECK_NE(port0, port1);
}
}
} |
2,617 | cpp | google/tsl | subprocess | tsl/platform/windows/subprocess.cc | tsl/platform/subprocess_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_DEFAULT_SUBPROCESS_H_
#define TENSORFLOW_TSL_PLATFORM_DEFAULT_SUBPROCESS_H_
#include <errno.h>
#include <unistd.h>
#include <string>
#include <vector>
#include "tsl/platform/macros.h"
#include "tsl/platform/mutex.h"
#include "tsl/platform/types.h"
namespace tsl {
class SubProcess {
public:
explicit SubProcess(int nfds = 3);
virtual ~SubProcess();
virtual void SetChannelAction(Channel chan, ChannelAction action);
virtual void SetProgram(const string& file, const std::vector<string>& argv);
virtual bool Start();
virtual bool Kill(int signal);
virtual bool Wait();
virtual int Communicate(const string* stdin_input, string* stdout_output,
string* stderr_output);
private:
static constexpr int kNFds = 3;
static bool chan_valid(int chan) { return ((chan >= 0) && (chan < kNFds)); }
static bool retry(int e) {
return ((e == EINTR) || (e == EAGAIN) || (e == EWOULDBLOCK));
}
void FreeArgs() TF_EXCLUSIVE_LOCKS_REQUIRED(data_mu_);
void ClosePipes() TF_EXCLUSIVE_LOCKS_REQUIRED(data_mu_);
bool WaitInternal(int* status);
mutable mutex proc_mu_;
bool running_ TF_GUARDED_BY(proc_mu_);
pid_t pid_ TF_GUARDED_BY(proc_mu_);
mutable mutex data_mu_ TF_ACQUIRED_AFTER(proc_mu_);
char* exec_path_ TF_GUARDED_BY(data_mu_);
char** exec_argv_ TF_GUARDED_BY(data_mu_);
ChannelAction action_[kNFds] TF_GUARDED_BY(data_mu_);
int parent_pipe_[kNFds] TF_GUARDED_BY(data_mu_);
int child_pipe_[kNFds] TF_GUARDED_BY(data_mu_);
SubProcess(const SubProcess&) = delete;
void operator=(const SubProcess&) = delete;
};
}
#endif
#include "tsl/platform/subprocess.h"
#include <fcntl.h>
#include <poll.h>
#include <signal.h>
#include <spawn.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <memory>
#include <vector>
#include "tsl/platform/logging.h"
#if !defined(__ANDROID_API__) || __ANDROID_API__ >= 28
#define USE_POSIX_SPAWN 1
#else
#define USE_POSIX_SPAWN 0
#endif
extern "C" {
extern char** environ;
}
namespace tsl {
SubProcess::SubProcess(int nfds)
: running_(false), pid_(-1), exec_path_(nullptr), exec_argv_(nullptr) {
for (int i = 0; i < kNFds; i++) {
action_[i] = ACTION_CLOSE;
parent_pipe_[i] = -1;
child_pipe_[i] = -1;
}
}
SubProcess::~SubProcess() {
mutex_lock procLock(proc_mu_);
mutex_lock dataLock(data_mu_);
pid_ = -1;
running_ = false;
FreeArgs();
ClosePipes();
}
void SubProcess::FreeArgs() {
free(exec_path_);
exec_path_ = nullptr;
if (exec_argv_) {
for (char** p = exec_argv_; *p != nullptr; p++) {
free(*p);
}
delete[] exec_argv_;
exec_argv_ = nullptr;
}
}
void SubProcess::ClosePipes() {
for (int i = 0; i < kNFds; i++) {
if (parent_pipe_[i] >= 0) {
if (close(parent_pipe_[i]) < 0) {
LOG(ERROR) << "close() failed: " << strerror(errno);
}
parent_pipe_[i] = -1;
}
if (child_pipe_[i] >= 0) {
if (close(child_pipe_[i]) < 0) {
LOG(ERROR) << "close() failed: " << strerror(errno);
}
child_pipe_[i] = -1;
}
}
}
void SubProcess::SetProgram(const string& file,
const std::vector<string>& argv) {
mutex_lock procLock(proc_mu_);
mutex_lock dataLock(data_mu_);
if (running_) {
LOG(FATAL) << "SetProgram called after the process was started.";
return;
}
FreeArgs();
exec_path_ = strdup(file.c_str());
if (exec_path_ == nullptr) {
LOG(FATAL) << "SetProgram failed to allocate file string.";
return;
}
int argc = argv.size();
exec_argv_ = new char*[argc + 1];
for (int i = 0; i < argc; i++) {
exec_argv_[i] = strdup(argv[i].c_str());
if (exec_argv_[i] == nullptr) {
LOG(FATAL) << "SetProgram failed to allocate command argument.";
return;
}
}
exec_argv_[argc] = nullptr;
}
void SubProcess::SetChannelAction(Channel chan, ChannelAction action) {
mutex_lock procLock(proc_mu_);
mutex_lock dataLock(data_mu_);
if (running_) {
LOG(FATAL) << "SetChannelAction called after the process was started.";
} else if (!chan_valid(chan)) {
LOG(FATAL) << "SetChannelAction called with invalid channel: " << chan;
} else if ((action != ACTION_CLOSE) && (action != ACTION_PIPE) &&
(action != ACTION_DUPPARENT)) {
LOG(FATAL) << "SetChannelAction called with invalid action: " << action;
} else {
action_[chan] = action;
}
}
#if USE_POSIX_SPAWN
bool SubProcess::Start() {
mutex_lock procLock(proc_mu_);
mutex_lock dataLock(data_mu_);
if (running_) {
LOG(ERROR) << "Start called after the process was started.";
return false;
}
if ((exec_path_ == nullptr) || (exec_argv_ == nullptr)) {
LOG(ERROR) << "Start called without setting a program.";
return false;
}
for (int i = 0; i < kNFds; i++) {
if (action_[i] == ACTION_PIPE) {
int pipe_fds[2];
if (pipe(pipe_fds) < 0) {
LOG(ERROR) << "Start cannot create pipe: " << strerror(errno);
ClosePipes();
return false;
}
if (i == 0) {
parent_pipe_[i] = pipe_fds[1];
child_pipe_[i] = pipe_fds[0];
} else {
parent_pipe_[i] = pipe_fds[0];
child_pipe_[i] = pipe_fds[1];
}
if (fcntl(parent_pipe_[i], F_SETFL, O_NONBLOCK) < 0) {
LOG(ERROR) << "Start cannot make pipe non-blocking: "
<< strerror(errno);
ClosePipes();
return false;
}
if (fcntl(parent_pipe_[i], F_SETFD, FD_CLOEXEC) < 0) {
LOG(ERROR) << "Start cannot make pipe close-on-exec: "
<< strerror(errno);
ClosePipes();
return false;
}
}
}
posix_spawn_file_actions_t file_actions;
int ret;
ret = posix_spawn_file_actions_init(&file_actions);
if (ret != 0) {
LOG(ERROR) << "Start cannot initialize POSIX file actions: "
<< strerror(ret);
ClosePipes();
return false;
}
int devnull_fd = -1;
for (int i = 0; i < kNFds; i++) {
if (parent_pipe_[i] >= 0) {
ret = posix_spawn_file_actions_addclose(&file_actions, parent_pipe_[i]);
if (ret != 0) {
LOG(ERROR) << "posix_spawn_file_actions_addclose() failed: "
<< strerror(ret);
}
}
switch (action_[i]) {
case ACTION_DUPPARENT:
break;
case ACTION_PIPE:
ret =
posix_spawn_file_actions_adddup2(&file_actions, child_pipe_[i], i);
if (ret != 0) {
LOG(ERROR) << "posix_spawn_file_actions_adddup2() failed: "
<< strerror(ret);
}
ret = posix_spawn_file_actions_addclose(&file_actions, child_pipe_[i]);
if (ret != 0) {
LOG(ERROR) << "posix_spawn_file_actions_addclose() failed: "
<< strerror(ret);
}
break;
case ACTION_CLOSE:
default:
if (i <= CHAN_STDERR) {
if (devnull_fd < 0) {
ret = posix_spawn_file_actions_addopen(&file_actions, i,
"/dev/null", O_RDWR, 0);
if (ret != 0) {
LOG(ERROR) << "posix_spawn_file_actions_addopen() failed: "
<< strerror(ret);
}
devnull_fd = i;
} else {
ret =
posix_spawn_file_actions_adddup2(&file_actions, devnull_fd, i);
if (ret != 0) {
LOG(ERROR) << "posix_spawn_file_actions_adddup2() failed: "
<< strerror(ret);
}
}
} else {
ret = posix_spawn_file_actions_addclose(&file_actions, i);
if (ret != 0) {
LOG(ERROR) << "posix_spawn_file_actions_addclose() failed: "
<< strerror(ret);
}
}
break;
}
}
ret = posix_spawnp(&pid_, exec_path_, &file_actions, nullptr, exec_argv_,
environ);
if (ret != 0) {
LOG(INFO) << "Start cannot spawn child process: " << strerror(ret);
ClosePipes();
return false;
}
ret = posix_spawn_file_actions_destroy(&file_actions);
if (ret != 0) {
LOG(WARNING) << "Start cannot destroy POSIX file actions: "
<< strerror(ret);
}
running_ = true;
for (int i = 0; i < kNFds; i++) {
if (child_pipe_[i] >= 0) {
if (close(child_pipe_[i]) < 0) {
LOG(ERROR) << "close() failed: " << strerror(errno);
}
child_pipe_[i] = -1;
}
}
return true;
}
#else
bool SubProcess::Start() {
mutex_lock procLock(proc_mu_);
mutex_lock dataLock(data_mu_);
if (running_) {
LOG(ERROR) << "Start called after the process was started.";
return false;
}
if ((exec_path_ == nullptr) || (exec_argv_ == nullptr)) {
LOG(ERROR) << "Start called without setting a program.";
return false;
}
for (int i = 0; i < kNFds; i++) {
if (action_[i] == ACTION_PIPE) {
int pipe_fds[2];
if (pipe(pipe_fds) < 0) {
LOG(ERROR) << "Start cannot create pipe: " << strerror(errno);
ClosePipes();
return false;
}
if (i == 0) {
parent_pipe_[i] = pipe_fds[1];
child_pipe_[i] = pipe_fds[0];
} else {
parent_pipe_[i] = pipe_fds[0];
child_pipe_[i] = pipe_fds[1];
}
if (fcntl(parent_pipe_[i], F_SETFL, O_NONBLOCK) < 0) {
LOG(ERROR) << "Start cannot make pipe non-blocking: "
<< strerror(errno);
ClosePipes();
return false;
}
if (fcntl(parent_pipe_[i], F_SETFD, FD_CLOEXEC) < 0) {
LOG(ERROR) << "Start cannot make pipe close-on-exec: "
<< strerror(errno);
ClosePipes();
return false;
}
}
}
pid_ = fork();
if (pid_ < 0) {
LOG(ERROR) << "Start cannot fork() child process: " << strerror(errno);
ClosePipes();
return false;
}
if (pid_ > 0) {
running_ = true;
for (int i = 0; i < kNFds; i++) {
if (child_pipe_[i] >= 0) {
if (close(child_pipe_[i]) < 0) {
LOG(ERROR) << "close() failed: " << strerror(errno);
}
child_pipe_[i] = -1;
}
}
return true;
}
int devnull_fd = -1;
for (int i = 0; i < kNFds; i++) {
if (parent_pipe_[i] >= 0) {
if (close(parent_pipe_[i]) < 0) {
LOG(ERROR) << "close() failed: " << strerror(errno);
}
parent_pipe_[i] = -1;
}
switch (action_[i]) {
case ACTION_DUPPARENT:
break;
case ACTION_PIPE:
while (dup2(child_pipe_[i], i) < 0) {
if (!retry(errno)) {
_exit(1);
}
}
if (close(child_pipe_[i]) < 0) {
LOG(ERROR) << "close() failed: " << strerror(errno);
}
child_pipe_[i] = -1;
break;
case ACTION_CLOSE:
default:
if (i <= CHAN_STDERR) {
if (devnull_fd < 0) {
while ((devnull_fd = open("/dev/null", O_RDWR, 0)) < 0) {
if (!retry(errno)) {
_exit(1);
}
}
}
while (dup2(devnull_fd, i) < 0) {
if (!retry(errno)) {
_exit(1);
}
}
} else {
if (close(i) < 0) {
LOG(ERROR) << "close() failed: " << strerror(errno);
}
}
break;
}
}
if (devnull_fd >= 0) {
if (close(devnull_fd) < 0) {
LOG(ERROR) << "close() failed: " << strerror(errno);
}
}
execvp(exec_path_, exec_argv_);
_exit(1);
}
#endif
bool SubProcess::Wait() {
int status;
return WaitInternal(&status);
}
bool SubProcess::WaitInternal(int* status) {
proc_mu_.lock();
bool running = running_;
pid_t pid = pid_;
proc_mu_.unlock();
bool ret = false;
if (running && (pid > 1)) {
pid_t cpid;
int cstat;
bool done = false;
while (!done) {
cpid = waitpid(pid, &cstat, 0);
if ((cpid < 0) && !retry(errno)) {
done = true;
} else if ((cpid == pid) && (WIFEXITED(cstat) || WIFSIGNALED(cstat))) {
*status = cstat;
ret = true;
done = true;
}
}
}
proc_mu_.lock();
if ((running_ == running) && (pid_ == pid)) {
running_ = false;
pid_ = -1;
}
proc_mu_.unlock();
return ret;
}
bool SubProcess::Kill(int signal) {
proc_mu_.lock();
bool running = running_;
pid_t pid = pid_;
proc_mu_.unlock();
bool ret = false;
if (running && (pid > 1)) {
ret = (kill(pid, signal) == 0);
}
return ret;
}
int SubProcess::Communicate(const string* stdin_input, string* stdout_output,
string* stderr_output) {
struct pollfd fds[kNFds];
size_t nbytes[kNFds];
string* iobufs[kNFds];
int fd_count = 0;
proc_mu_.lock();
bool running = running_;
proc_mu_.unlock();
if (!running) {
LOG(ERROR) << "Communicate called without a running process.";
return 1;
}
struct sigaction act;
if (sigaction(SIGPIPE, nullptr, &act) < 0) {
LOG(ERROR) << "Communicate cannot get SIGPIPE handler: " << strerror(errno);
return 1;
}
if (act.sa_handler == SIG_DFL) {
memset(&act, 0, sizeof(act));
act.sa_handler = SIG_IGN;
sigemptyset(&act.sa_mask);
if (sigaction(SIGPIPE, &act, nullptr) < 0) {
LOG(ERROR) << "Communicate cannot ignore SIGPIPE: " << strerror(errno);
return 1;
}
}
data_mu_.lock();
for (int i = 0; i < kNFds; i++) {
if (action_[i] == ACTION_PIPE) {
switch (i) {
case CHAN_STDIN:
if (stdin_input == nullptr) {
if (close(parent_pipe_[i]) < 0) {
LOG(ERROR) << "close() failed: " << strerror(errno);
}
parent_pipe_[i] = -1;
continue;
}
iobufs[fd_count] = const_cast<string*>(stdin_input);
break;
case CHAN_STDOUT:
iobufs[fd_count] = stdout_output;
break;
case CHAN_STDERR:
iobufs[fd_count] = stderr_output;
break;
default:
iobufs[fd_count] = nullptr;
break;
}
nbytes[fd_count] = 0;
fds[fd_count].fd = parent_pipe_[i];
fds[fd_count].events = (i > 0) ? POLLIN : POLLOUT;
fds[fd_count].revents = 0;
fd_count++;
}
}
int fd_remain = fd_count;
char buf[4096];
while (fd_remain > 0) {
int n = poll(fds, fd_count, -1);
if ((n < 0) && !retry(errno)) {
LOG(ERROR) << "Communicate cannot poll(): " << strerror(errno);
fd_remain = 0;
} else if (n == 0) {
LOG(ERROR) << "Communicate cannot poll(): timeout not possible";
fd_remain = 0;
} else if (n > 0) {
for (int i = 0; i < fd_count; i++) {
if ((fds[i].revents & (POLLIN | POLLHUP)) != 0) {
ssize_t n = read(fds[i].fd, buf, sizeof(buf));
if (n > 0) {
if (iobufs[i] != nullptr) {
iobufs[i]->append(buf, n);
nbytes[i] += n;
}
} else if ((n == 0) || !retry(errno)) {
fds[i].fd = -1;
fd_remain--;
}
} else if ((fds[i].revents & POLLOUT) != 0) {
ssize_t n = iobufs[i]->size() - nbytes[i];
if (n > 0) {
n = write(fds[i].fd, iobufs[i]->c_str() + nbytes[i], n);
}
if (n >= 0) {
nbytes[i] += n;
if (nbytes[i] >= iobufs[i]->size()) {
fds[i].fd = -1;
fd_remain--;
if (close(parent_pipe_[CHAN_STDIN]) < 0) {
LOG(ERROR) << "close() failed: " << strerror(errno);
}
parent_pipe_[CHAN_STDIN] = -1;
}
} else if (!retry(errno)) {
fds[i].fd = -1;
fd_remain--;
}
} else if ((fds[i].revents & (POLLERR | POLLNVAL)) != 0) {
fds[i].fd = -1;
fd_remain--;
}
}
}
}
data_mu_.unlock();
int status;
return WaitInternal(&status) ? status : -1;
}
std::unique_ptr<SubProcess> CreateSubProcess(const std::vector<string>& argv) {
std::unique_ptr<SubProcess> proc(new SubProcess());
proc->SetProgram(argv[0], argv);
proc->SetChannelAction(CHAN_STDERR, ACTION_DUPPARENT);
proc->SetChannelAction(CHAN_STDOUT, ACTION_DUPPARENT);
return proc;
}
} | #include "tsl/platform/subprocess.h"
#include <stdlib.h>
#include <algorithm>
#include <string>
#include "tsl/lib/core/status_test_util.h"
#include "tsl/platform/path.h"
#include "tsl/platform/strcat.h"
#include "tsl/platform/test.h"
#ifdef PLATFORM_WINDOWS
#define WIFEXITED(code) ((code) != 3)
#define WEXITSTATUS(code) (code)
#define SIGKILL 9
#else
#include <sys/wait.h>
#endif
namespace tsl {
namespace {
string EchoProgram() {
std::string path =
io::JoinPath(testing::TslSrcRoot(), "platform", "testdata", "test_echo");
return tsl::io::AppendDotExeIfWindows(path);
}
string EchoArgv1Program() {
std::string path = io::JoinPath(testing::TslSrcRoot(), "platform", "testdata",
"test_echo_argv_1");
return tsl::io::AppendDotExeIfWindows(path);
}
string NoopProgram() {
std::string path =
io::JoinPath(testing::TslSrcRoot(), "platform", "testdata", "test_noop");
return tsl::io::AppendDotExeIfWindows(path);
}
string StdErrProgram() {
std::string path = io::JoinPath(testing::TslSrcRoot(), "platform", "testdata",
"test_stderr");
return tsl::io::AppendDotExeIfWindows(path);
}
class SubProcessTest : public ::testing::Test {};
TEST_F(SubProcessTest, NoOutputNoComm) {
tsl::SubProcess proc;
proc.SetProgram(NoopProgram().c_str(), {NoopProgram()});
EXPECT_TRUE(proc.Start());
EXPECT_TRUE(proc.Wait());
}
TEST_F(SubProcessTest, NoOutput) {
tsl::SubProcess proc;
proc.SetProgram(NoopProgram().c_str(), {NoopProgram()});
proc.SetChannelAction(CHAN_STDOUT, ACTION_PIPE);
proc.SetChannelAction(CHAN_STDERR, ACTION_PIPE);
EXPECT_TRUE(proc.Start());
string out, err;
int status = proc.Communicate(nullptr, &out, &err);
EXPECT_TRUE(WIFEXITED(status));
EXPECT_EQ(0, WEXITSTATUS(status));
EXPECT_EQ("", out);
EXPECT_EQ("", err);
}
TEST_F(SubProcessTest, Stdout) {
tsl::SubProcess proc;
const char test_string[] = "hello_world";
proc.SetProgram(EchoArgv1Program().c_str(),
{EchoArgv1Program(), test_string});
proc.SetChannelAction(CHAN_STDOUT, ACTION_PIPE);
proc.SetChannelAction(CHAN_STDERR, ACTION_PIPE);
EXPECT_TRUE(proc.Start());
string out, err;
int status = proc.Communicate(nullptr, &out, &err);
EXPECT_TRUE(WIFEXITED(status));
EXPECT_EQ(0, WEXITSTATUS(status));
EXPECT_EQ(test_string, out);
EXPECT_EQ("", err);
}
TEST_F(SubProcessTest, StdoutIgnored) {
tsl::SubProcess proc;
const char test_string[] = "hello_world";
proc.SetProgram(EchoArgv1Program().c_str(),
{EchoArgv1Program(), test_string});
proc.SetChannelAction(CHAN_STDOUT, ACTION_PIPE);
proc.SetChannelAction(CHAN_STDERR, ACTION_PIPE);
EXPECT_TRUE(proc.Start());
int status = proc.Communicate(nullptr, nullptr, nullptr);
EXPECT_TRUE(WIFEXITED(status));
EXPECT_EQ(0, WEXITSTATUS(status));
}
TEST_F(SubProcessTest, Stderr) {
tsl::SubProcess proc;
const char test_string[] = "muh_failure!";
proc.SetProgram(StdErrProgram().c_str(), {StdErrProgram(), test_string});
proc.SetChannelAction(CHAN_STDOUT, ACTION_PIPE);
proc.SetChannelAction(CHAN_STDERR, ACTION_PIPE);
EXPECT_TRUE(proc.Start());
string out, err;
int status = proc.Communicate(nullptr, &out, &err);
EXPECT_TRUE(WIFEXITED(status));
EXPECT_NE(0, WEXITSTATUS(status));
EXPECT_EQ("", out);
EXPECT_EQ(test_string, err);
}
TEST_F(SubProcessTest, StderrIgnored) {
tsl::SubProcess proc;
const char test_string[] = "muh_failure!";
proc.SetProgram(StdErrProgram().c_str(), {StdErrProgram(), test_string});
proc.SetChannelAction(CHAN_STDOUT, ACTION_PIPE);
proc.SetChannelAction(CHAN_STDERR, ACTION_PIPE);
EXPECT_TRUE(proc.Start());
int status = proc.Communicate(nullptr, nullptr, nullptr);
EXPECT_TRUE(WIFEXITED(status));
EXPECT_NE(0, WEXITSTATUS(status));
}
TEST_F(SubProcessTest, Stdin) {
tsl::SubProcess proc;
proc.SetProgram(EchoProgram().c_str(), {EchoProgram()});
proc.SetChannelAction(CHAN_STDIN, ACTION_PIPE);
EXPECT_TRUE(proc.Start());
string in = "foobar\nbarfoo\nhaha\n";
int status = proc.Communicate(&in, nullptr, nullptr);
EXPECT_TRUE(WIFEXITED(status));
EXPECT_EQ(0, WEXITSTATUS(status));
}
TEST_F(SubProcessTest, StdinStdout) {
tsl::SubProcess proc;
proc.SetProgram(EchoProgram().c_str(), {EchoProgram()});
proc.SetChannelAction(CHAN_STDIN, ACTION_PIPE);
proc.SetChannelAction(CHAN_STDOUT, ACTION_PIPE);
EXPECT_TRUE(proc.Start());
string in = "foobar\nbarfoo\nhaha\n";
string out;
int status = proc.Communicate(&in, &out, nullptr);
EXPECT_TRUE(WIFEXITED(status));
EXPECT_EQ(0, WEXITSTATUS(status));
out.erase(std::remove(out.begin(), out.end(), '\r'), out.end());
EXPECT_EQ(in, out);
}
TEST_F(SubProcessTest, StdinChildExit) {
tsl::SubProcess proc;
proc.SetProgram(NoopProgram().c_str(), {NoopProgram()});
proc.SetChannelAction(CHAN_STDIN, ACTION_PIPE);
EXPECT_TRUE(proc.Start());
string in;
in.reserve(1000000);
for (int i = 0; i < 100000; i++) {
in += "hello xyz\n";
}
int status = proc.Communicate(&in, nullptr, nullptr);
EXPECT_TRUE(WIFEXITED(status));
EXPECT_EQ(0, WEXITSTATUS(status));
}
TEST_F(SubProcessTest, StdinStdoutOverlap) {
tsl::SubProcess proc;
proc.SetProgram(EchoProgram().c_str(), {EchoProgram()});
proc.SetChannelAction(CHAN_STDIN, ACTION_PIPE);
proc.SetChannelAction(CHAN_STDOUT, ACTION_PIPE);
EXPECT_TRUE(proc.Start());
string in;
in.reserve(1000000);
for (int i = 0; i < 100000; i++) {
in += "hello xyz\n";
}
string out;
int status = proc.Communicate(&in, &out, nullptr);
EXPECT_TRUE(WIFEXITED(status));
EXPECT_EQ(0, WEXITSTATUS(status));
out.erase(std::remove(out.begin(), out.end(), '\r'), out.end());
EXPECT_EQ(in, out);
}
TEST_F(SubProcessTest, KillProc) {
tsl::SubProcess proc;
proc.SetProgram(EchoProgram().c_str(), {EchoProgram()});
proc.SetChannelAction(CHAN_STDIN, ACTION_PIPE);
proc.SetChannelAction(CHAN_STDOUT, ACTION_PIPE);
EXPECT_TRUE(proc.Start());
EXPECT_TRUE(proc.Kill(SIGKILL));
EXPECT_TRUE(proc.Wait());
EXPECT_FALSE(proc.Kill(SIGKILL));
}
}
} |
2,618 | cpp | google/tsl | stacktrace_handler | tsl/platform/windows/stacktrace_handler.cc | tsl/platform/stacktrace_handler_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_STACKTRACE_HANDLER_H_
#define TENSORFLOW_TSL_PLATFORM_STACKTRACE_HANDLER_H_
namespace tsl {
namespace testing {
void InstallStacktraceHandler();
}
}
#endif
#include "tsl/platform/platform.h"
#if !defined(IS_MOBILE_PLATFORM) && defined(PLATFORM_POSIX) && \
(defined(__clang__) || defined(__GNUC__))
#define TF_GENERATE_STACKTRACE
#endif
#if defined(TF_GENERATE_STACKTRACE)
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <unistd.h>
#include <string>
#include "tsl/platform/stacktrace.h"
#endif
namespace tsl {
namespace testing {
#if defined(TF_GENERATE_STACKTRACE)
inline void SafePrintStackTrace() {
static const char begin_msg[] = "*** BEGIN MANGLED STACK TRACE ***\n";
(void)!write(STDERR_FILENO, begin_msg, strlen(begin_msg));
int buffer_size = 128;
void *trace[128];
buffer_size = backtrace(trace, buffer_size);
backtrace_symbols_fd(trace, buffer_size, STDERR_FILENO);
static const char end_msg[] = "*** END MANGLED STACK TRACE ***\n\n";
(void)!write(STDERR_FILENO, end_msg, strlen(end_msg));
}
static void StacktraceHandler(int sig, siginfo_t *si, void *v) {
struct itimerval timer;
timer.it_value.tv_sec = 60;
timer.it_value.tv_usec = 0;
timer.it_interval.tv_sec = 0;
timer.it_interval.tv_usec = 0;
setitimer(ITIMER_REAL, &timer, 0);
struct sigaction sa_timeout;
memset(&sa_timeout, 0, sizeof(sa_timeout));
sa_timeout.sa_handler = SIG_DFL;
sigaction(SIGALRM, &sa_timeout, 0);
char buf[128];
snprintf(buf, sizeof(buf), "*** Received signal %d ***\n", sig);
(void)!write(STDERR_FILENO, buf, strlen(buf));
SafePrintStackTrace();
std::string stacktrace = CurrentStackTrace();
(void)!write(STDERR_FILENO, stacktrace.c_str(), stacktrace.length());
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sa.sa_handler = SIG_DFL;
sigaction(SIGABRT, &sa, NULL);
abort();
}
void InstallStacktraceHandler() {
int handled_signals[] = {SIGSEGV, SIGABRT, SIGBUS, SIGILL, SIGFPE};
size_t array_limit = sizeof(handled_signals) / sizeof(int);
for (size_t i = 0; i < array_limit; i++) {
int sig = handled_signals[i];
struct sigaction sa;
struct sigaction osa;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_SIGINFO | SA_RESETHAND;
sa.sa_sigaction = &StacktraceHandler;
if (sigaction(sig, &sa, &osa) != 0) {
char buf[128];
snprintf(buf, sizeof(buf),
"Warning, can't install backtrace signal handler for signal %d, "
"errno:%d \n",
sig, errno);
(void)!write(STDERR_FILENO, buf, strlen(buf));
} else if (osa.sa_handler != SIG_DFL) {
char buf[128];
snprintf(buf, sizeof(buf),
"Warning, backtrace signal handler for signal %d overwrote "
"previous handler.\n",
sig);
(void)!write(STDERR_FILENO, buf, strlen(buf));
}
}
}
#else
void InstallStacktraceHandler() {}
#endif
}
} | #include <csignal>
#include "tsl/platform/logging.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace {
TEST(StacktraceHandlerTest, GeneratesStacktrace) {
EXPECT_DEATH(raise(SIGABRT), "testing::internal::UnitTestImpl::RunAllTests");
}
}
} |
2,619 | cpp | google/tsl | stacktrace | tsl/platform/windows/stacktrace.cc | tsl/platform/stacktrace_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_DEFAULT_STACKTRACE_H_
#define TENSORFLOW_TSL_PLATFORM_DEFAULT_STACKTRACE_H_
#include "tsl/platform/platform.h"
#if !defined(IS_MOBILE_PLATFORM) && (defined(__clang__) || defined(__GNUC__))
#define TF_HAS_STACKTRACE
#endif
#if defined(TF_HAS_STACKTRACE)
#include <dlfcn.h>
#include <execinfo.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#endif
#include <sstream>
#include <string>
#include "tsl/platform/abi.h"
namespace tsl {
inline std::string CurrentStackTrace() {
#if defined(TF_HAS_STACKTRACE)
std::stringstream ss("");
ss << "*** Begin stack trace ***" << std::endl;
int buffer_size = 128;
void* trace[128];
buffer_size = backtrace(trace, buffer_size);
for (int i = 0; i < buffer_size; ++i) {
const char* symbol = "";
Dl_info info;
if (dladdr(trace[i], &info)) {
if (info.dli_sname != nullptr) {
symbol = info.dli_sname;
}
}
std::string demangled = port::MaybeAbiDemangle(symbol);
if (demangled.length()) {
ss << "\t" << demangled << std::endl;
} else {
ss << "\t" << symbol << std::endl;
}
}
ss << "*** End stack trace ***" << std::endl;
return ss.str();
#else
return std::string();
#endif
}
inline void DebugWriteToString(const char* data, void* arg) {
reinterpret_cast<std::string*>(arg)->append(data);
}
class SavedStackTrace {
public:
SavedStackTrace() {}
void CreateCurrent(int skip_count) {}
void Reset() {}
typedef void DebugWriter(const char*, void*);
void Dump(DebugWriter* writerfn, void* arg) const {}
int depth() const { return 0; }
void* const* stack() const { return stack_; }
private:
void* stack_[32];
};
}
#endif
#include "tsl/platform/windows/stacktrace.h"
#include <windows.h>
#include <dbghelp.h>
#include <string>
#include "tsl/platform/mutex.h"
#pragma comment(lib, "dbghelp.lib")
namespace tsl {
static bool SymbolsAreAvailableInit() {
SymSetOptions(SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS);
return SymInitialize(GetCurrentProcess(), NULL, true);
}
static bool SymbolsAreAvailable() {
static bool kSymbolsAvailable = SymbolsAreAvailableInit();
return kSymbolsAvailable;
}
std::string CurrentStackTrace() {
HANDLE current_process = GetCurrentProcess();
static constexpr int kMaxStackFrames = 64;
void* trace[kMaxStackFrames];
int num_frames = CaptureStackBackTrace(0, kMaxStackFrames, trace, NULL);
static mutex mu(tsl::LINKER_INITIALIZED);
std::string stacktrace;
for (int i = 0; i < num_frames; ++i) {
const char* symbol = "(unknown)";
if (SymbolsAreAvailable()) {
char symbol_info_buffer[sizeof(SYMBOL_INFO) +
MAX_SYM_NAME * sizeof(TCHAR)];
SYMBOL_INFO* symbol_ptr =
reinterpret_cast<SYMBOL_INFO*>(symbol_info_buffer);
symbol_ptr->SizeOfStruct = sizeof(SYMBOL_INFO);
symbol_ptr->MaxNameLen = MAX_SYM_NAME;
mutex_lock lock(mu);
if (SymFromAddr(current_process, reinterpret_cast<DWORD64>(trace[i]), 0,
symbol_ptr)) {
symbol = symbol_ptr->Name;
}
}
char buffer[256];
snprintf(buffer, sizeof(buffer), "0x%p\t%s", trace[i], symbol);
stacktrace += buffer;
stacktrace += "\n";
}
return stacktrace;
}
} | #include "tsl/platform/stacktrace.h"
#include <string>
#include "tsl/platform/logging.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace {
#if defined(TF_HAS_STACKTRACE)
TEST(StacktraceTest, StacktraceWorks) {
std::string stacktrace = CurrentStackTrace();
LOG(INFO) << "CurrentStackTrace():\n" << stacktrace;
std::string expected_frame = "testing::internal::UnitTestImpl::RunAllTests";
EXPECT_NE(stacktrace.find(expected_frame), std::string::npos);
}
#endif
}
} |
2,620 | cpp | google/tsl | logging | tsl/platform/default/logging.cc | tsl/platform/logging_test.cc | #if defined(_WIN32)
#pragma warning(disable : 4716)
#endif
#ifndef TENSORFLOW_TSL_PLATFORM_DEFAULT_LOGGING_H_
#define TENSORFLOW_TSL_PLATFORM_DEFAULT_LOGGING_H_
#include <atomic>
#include <limits>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
#include "absl/base/log_severity.h"
#include "absl/strings/string_view.h"
#include "tsl/platform/macros.h"
#include "tsl/platform/types.h"
#undef ERROR
#undef LOG
#undef LOG_EVERY_N
#undef LOG_FIRST_N
#undef LOG_EVERY_POW_2
#undef LOG_EVERY_N_SEC
#undef VLOG
#undef CHECK
#undef CHECK_EQ
#undef CHECK_NE
#undef CHECK_LT
#undef CHECK_LE
#undef CHECK_GT
#undef CHECK_GE
#undef DCHECK
#undef DCHECK_EQ
#undef DCHECK_NE
#undef DCHECK_LT
#undef DCHECK_LE
#undef DCHECK_GT
#undef DCHECK_GE
#undef QCHECK
#undef QCHECK_EQ
#undef QCHECK_NE
#undef QCHECK_LT
#undef QCHECK_LE
#undef QCHECK_GT
#undef QCHECK_GE
#undef PCHECK
namespace tsl {
const int INFO = 0;
const int WARNING = 1;
const int ERROR = 2;
const int FATAL = 3;
const int NUM_SEVERITIES = 4;
namespace internal {
void LogString(const char* fname, int line, int severity,
const std::string& message);
class LogMessage : public std::basic_ostringstream<char> {
public:
LogMessage(const char* fname, int line, int severity);
~LogMessage() override;
LogMessage& AtLocation(const char* fname, int line);
static int64_t MaxVLogLevel();
static bool VmoduleActivated(const char* fname, int level);
protected:
void GenerateLogMessage();
private:
const char* fname_;
int line_;
int severity_;
};
struct Voidifier {
template <typename T>
void operator&(const T&) const {}
};
class LogMessageFatal : public LogMessage {
public:
LogMessageFatal(const char* file, int line) TF_ATTRIBUTE_COLD;
TF_ATTRIBUTE_NORETURN ~LogMessageFatal() override;
};
class LogMessageNull : public std::basic_ostringstream<char> {
public:
LogMessageNull() {}
~LogMessageNull() override {}
};
#define _TF_LOG_INFO \
::tsl::internal::LogMessage(__FILE__, __LINE__, ::tsl::INFO)
#define _TF_LOG_WARNING \
::tsl::internal::LogMessage(__FILE__, __LINE__, ::tsl::WARNING)
#define _TF_LOG_ERROR \
::tsl::internal::LogMessage(__FILE__, __LINE__, ::tsl::ERROR)
#define _TF_LOG_FATAL ::tsl::internal::LogMessageFatal(__FILE__, __LINE__)
#define _TF_LOG_QFATAL _TF_LOG_FATAL
#ifdef NDEBUG
#define _TF_LOG_DFATAL _TF_LOG_ERROR
#else
#define _TF_LOG_DFATAL _TF_LOG_FATAL
#endif
#define LOG(severity) _TF_LOG_##severity
#ifdef IS_MOBILE_PLATFORM
#define VLOG_IS_ON(lvl) ((lvl) <= 0)
#else
#define VLOG_IS_ON(lvl) \
(([](int level, const char* fname) { \
static const bool vmodule_activated = \
::tsl::internal::LogMessage::VmoduleActivated(fname, level); \
return vmodule_activated; \
})(lvl, __FILE__))
#endif
#define VLOG(level) \
TF_PREDICT_TRUE(!VLOG_IS_ON(level)) \
? (void)0 \
: ::tsl::internal::Voidifier() & \
::tsl::internal::LogMessage(__FILE__, __LINE__, tsl::INFO)
#ifndef NDEBUG
#define DVLOG VLOG
#else
#define DVLOG(verbose_level) \
while (false && (verbose_level) > 0) ::tsl::internal::LogMessageNull()
#endif
class LogEveryNState {
public:
bool ShouldLog(int n);
uint32_t counter() { return counter_.load(std::memory_order_relaxed); }
private:
std::atomic<uint32> counter_{0};
};
class LogFirstNState {
public:
bool ShouldLog(int n);
uint32 counter() { return counter_.load(std::memory_order_relaxed); }
private:
std::atomic<uint32> counter_{0};
};
class LogEveryPow2State {
public:
bool ShouldLog(int ignored);
uint32 counter() { return counter_.load(std::memory_order_relaxed); }
private:
std::atomic<uint32> counter_{0};
};
class LogEveryNSecState {
public:
bool ShouldLog(double seconds);
uint32 counter() { return counter_.load(std::memory_order_relaxed); }
private:
std::atomic<uint32> counter_{0};
std::atomic<int64_t> next_log_time_cycles_{0};
};
#define LOGGING_INTERNAL_STATEFUL_CONDITION(kind, condition, arg) \
for (bool logging_internal_stateful_condition_do_log(condition); \
logging_internal_stateful_condition_do_log; \
logging_internal_stateful_condition_do_log = false) \
for (static ::tsl::internal::Log##kind##State \
logging_internal_stateful_condition_state; \
logging_internal_stateful_condition_do_log && \
logging_internal_stateful_condition_state.ShouldLog(arg); \
logging_internal_stateful_condition_do_log = false) \
for (const uint32_t COUNTER ABSL_ATTRIBUTE_UNUSED = \
logging_internal_stateful_condition_state.counter(); \
logging_internal_stateful_condition_do_log; \
logging_internal_stateful_condition_do_log = false)
#define LOG_EVERY_N(severity, n) \
LOGGING_INTERNAL_STATEFUL_CONDITION(EveryN, true, n) \
LOG(severity)
#define LOG_FIRST_N(severity, n) \
LOGGING_INTERNAL_STATEFUL_CONDITION(FirstN, true, n) \
LOG(severity)
#define LOG_EVERY_POW_2(severity) \
LOGGING_INTERNAL_STATEFUL_CONDITION(EveryPow2, true, 0) \
LOG(severity)
#define LOG_EVERY_N_SEC(severity, n_seconds) \
LOGGING_INTERNAL_STATEFUL_CONDITION(EveryNSec, true, n_seconds) \
LOG(severity)
#define CHECK(condition) \
if (TF_PREDICT_FALSE(!(condition))) \
LOG(FATAL) << "Check failed: " #condition " "
template <typename T>
inline const T& GetReferenceableValue(const T& t) {
return t;
}
inline char GetReferenceableValue(char t) { return t; }
inline unsigned char GetReferenceableValue(unsigned char t) { return t; }
inline signed char GetReferenceableValue(signed char t) { return t; }
inline int16 GetReferenceableValue(int16_t t) { return t; }
inline uint16 GetReferenceableValue(uint16 t) { return t; }
inline int GetReferenceableValue(int t) { return t; }
inline unsigned int GetReferenceableValue(unsigned int t) { return t; }
inline int64_t GetReferenceableValue(int64_t t) { return t; }
inline uint64 GetReferenceableValue(uint64 t) { return t; }
template <typename T>
inline void MakeCheckOpValueString(std::ostream* os, const T& v) {
(*os) << v;
}
template <>
void MakeCheckOpValueString(std::ostream* os, const char& v);
template <>
void MakeCheckOpValueString(std::ostream* os, const signed char& v);
template <>
void MakeCheckOpValueString(std::ostream* os, const unsigned char& v);
#if LANG_CXX11
template <>
void MakeCheckOpValueString(std::ostream* os, const std::nullptr_t& v);
#endif
struct CheckOpString {
explicit CheckOpString(string* str) : str_(str) {}
explicit operator bool() const { return TF_PREDICT_FALSE(str_ != nullptr); }
string* str_;
};
template <typename T1, typename T2>
string* MakeCheckOpString(const T1& v1, const T2& v2,
const char* exprtext) TF_ATTRIBUTE_NOINLINE;
class CheckOpMessageBuilder {
public:
explicit CheckOpMessageBuilder(const char* exprtext);
~CheckOpMessageBuilder();
std::ostream* ForVar1() { return stream_; }
std::ostream* ForVar2();
string* NewString();
private:
std::ostringstream* stream_;
};
template <typename T1, typename T2>
string* MakeCheckOpString(const T1& v1, const T2& v2, const char* exprtext) {
CheckOpMessageBuilder comb(exprtext);
MakeCheckOpValueString(comb.ForVar1(), v1);
MakeCheckOpValueString(comb.ForVar2(), v2);
return comb.NewString();
}
#define TF_DEFINE_CHECK_OP_IMPL(name, op) \
template <typename T1, typename T2> \
inline string* name##Impl(const T1& v1, const T2& v2, \
const char* exprtext) { \
if (TF_PREDICT_TRUE(v1 op v2)) \
return NULL; \
else \
return ::tsl::internal::MakeCheckOpString(v1, v2, exprtext); \
} \
inline string* name##Impl(int v1, int v2, const char* exprtext) { \
return name##Impl<int, int>(v1, v2, exprtext); \
}
TF_DEFINE_CHECK_OP_IMPL(Check_EQ, ==)
inline string* Check_EQImpl(int v1, size_t v2, const char* exprtext) {
if (TF_PREDICT_FALSE(v1 < 0))
::tsl::internal::MakeCheckOpString(v1, v2, exprtext);
return Check_EQImpl(size_t(v1), v2, exprtext);
}
inline string* Check_EQImpl(size_t v1, int v2, const char* exprtext) {
return Check_EQImpl(v2, v1, exprtext);
}
TF_DEFINE_CHECK_OP_IMPL(Check_NE, !=)
inline string* Check_NEImpl(int v1, size_t v2, const char* exprtext) {
if (v1 < 0) return NULL;
return Check_NEImpl(size_t(v1), v2, exprtext);
}
inline string* Check_NEImpl(size_t v1, int v2, const char* exprtext) {
return Check_NEImpl(v2, v1, exprtext);
}
TF_DEFINE_CHECK_OP_IMPL(Check_LE, <=)
inline string* Check_LEImpl(int v1, size_t v2, const char* exprtext) {
if (v1 <= 0) return NULL;
return Check_LEImpl(size_t(v1), v2, exprtext);
}
inline string* Check_LEImpl(size_t v1, int v2, const char* exprtext) {
if (TF_PREDICT_FALSE(v2 < 0))
return ::tsl::internal::MakeCheckOpString(v1, v2, exprtext);
return Check_LEImpl(v1, size_t(v2), exprtext);
}
TF_DEFINE_CHECK_OP_IMPL(Check_LT, <)
inline string* Check_LTImpl(int v1, size_t v2, const char* exprtext) {
if (v1 < 0) return NULL;
return Check_LTImpl(size_t(v1), v2, exprtext);
}
inline string* Check_LTImpl(size_t v1, int v2, const char* exprtext) {
if (v2 < 0) return ::tsl::internal::MakeCheckOpString(v1, v2, exprtext);
return Check_LTImpl(v1, size_t(v2), exprtext);
}
template <typename T1, typename T2>
inline string* Check_GEImpl(const T1& v1, const T2& v2, const char* exprtext) {
return Check_LEImpl(v2, v1, exprtext);
}
template <typename T1, typename T2>
inline string* Check_GTImpl(const T1& v1, const T2& v2, const char* exprtext) {
return Check_LTImpl(v2, v1, exprtext);
}
#undef TF_DEFINE_CHECK_OP_IMPL
#define CHECK_OP_LOG(name, op, val1, val2) \
while (::tsl::internal::CheckOpString _result{::tsl::internal::name##Impl( \
::tsl::internal::GetReferenceableValue(val1), \
::tsl::internal::GetReferenceableValue(val2), #val1 " " #op " " #val2)}) \
::tsl::internal::LogMessageFatal(__FILE__, __LINE__) << *(_result.str_)
#define CHECK_OP(name, op, val1, val2) CHECK_OP_LOG(name, op, val1, val2)
#define CHECK_EQ(val1, val2) CHECK_OP(Check_EQ, ==, val1, val2)
#define CHECK_NE(val1, val2) CHECK_OP(Check_NE, !=, val1, val2)
#define CHECK_LE(val1, val2) CHECK_OP(Check_LE, <=, val1, val2)
#define CHECK_LT(val1, val2) CHECK_OP(Check_LT, <, val1, val2)
#define CHECK_GE(val1, val2) CHECK_OP(Check_GE, >=, val1, val2)
#define CHECK_GT(val1, val2) CHECK_OP(Check_GT, >, val1, val2)
#define CHECK_NOTNULL(val) \
::tsl::internal::CheckNotNull(__FILE__, __LINE__, \
"'" #val "' Must be non NULL", (val))
#ifndef NDEBUG
#define DCHECK(condition) CHECK(condition)
#define DCHECK_EQ(val1, val2) CHECK_EQ(val1, val2)
#define DCHECK_NE(val1, val2) CHECK_NE(val1, val2)
#define DCHECK_LE(val1, val2) CHECK_LE(val1, val2)
#define DCHECK_LT(val1, val2) CHECK_LT(val1, val2)
#define DCHECK_GE(val1, val2) CHECK_GE(val1, val2)
#define DCHECK_GT(val1, val2) CHECK_GT(val1, val2)
#else
#define DCHECK(condition) \
while (false && (condition)) LOG(FATAL)
#define _TF_DCHECK_NOP(x, y) \
while (false && ((void)(x), (void)(y), 0)) LOG(FATAL)
#define DCHECK_EQ(x, y) _TF_DCHECK_NOP(x, y)
#define DCHECK_NE(x, y) _TF_DCHECK_NOP(x, y)
#define DCHECK_LE(x, y) _TF_DCHECK_NOP(x, y)
#define DCHECK_LT(x, y) _TF_DCHECK_NOP(x, y)
#define DCHECK_GE(x, y) _TF_DCHECK_NOP(x, y)
#define DCHECK_GT(x, y) _TF_DCHECK_NOP(x, y)
#endif
#define QCHECK(condition) CHECK(condition)
#define QCHECK_EQ(x, y) CHECK_EQ(x, y)
#define QCHECK_NE(x, y) CHECK_NE(x, y)
#define QCHECK_LE(x, y) CHECK_LE(x, y)
#define QCHECK_LT(x, y) CHECK_LT(x, y)
#define QCHECK_GE(x, y) CHECK_GE(x, y)
#define QCHECK_GT(x, y) CHECK_GT(x, y)
template <typename T>
T&& CheckNotNull(const char* file, int line, const char* exprtext, T&& t) {
if (t == nullptr) {
LogMessageFatal(file, line) << string(exprtext);
}
return std::forward<T>(t);
}
int64_t MinLogLevelFromEnv();
int64_t MaxVLogLevelFromEnv();
}
class TFLogEntry {
static absl::LogSeverity AsAbslLogSeverity(int severity) {
return static_cast<absl::LogSeverity>(severity);
}
public:
explicit TFLogEntry(int severity, absl::string_view message)
: severity_(AsAbslLogSeverity(severity)), message_(message) {}
explicit TFLogEntry(int severity, absl::string_view fname, int line,
absl::string_view message)
: severity_(AsAbslLogSeverity(severity)),
fname_(fname),
line_(line),
message_(message) {}
absl::LogSeverity log_severity() const { return severity_; }
std::string FName() const { return fname_; }
int Line() const { return line_; }
std::string ToString() const { return message_; }
absl::string_view text_message() const { return message_; }
absl::string_view text_message_with_prefix() const { return message_; }
private:
const absl::LogSeverity severity_;
const std::string fname_;
int line_ = -1;
const std::string message_;
};
class TFLogSink {
public:
virtual ~TFLogSink() = default;
virtual void Send(const TFLogEntry& entry) = 0;
virtual void WaitTillSent() {}
};
class TFDefaultLogSink : public TFLogSink {
public:
void Send(const TFLogEntry& entry) override;
};
void TFAddLogSink(TFLogSink* sink);
void TFRemoveLogSink(TFLogSink* sink);
std::vector<TFLogSink*> TFGetLogSinks();
void UpdateLogVerbosityIfDefined(const char* env_var);
}
#endif
#include "tsl/platform/default/logging.h"
#include "absl/base/internal/cycleclock.h"
#include "absl/base/internal/sysinfo.h"
#include "tsl/platform/env_time.h"
#include "tsl/platform/macros.h"
#include "tsl/platform/mutex.h"
#if defined(PLATFORM_POSIX_ANDROID)
#include <android/log.h>
#include <iostream>
#include <sstream>
#endif
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <algorithm>
#include <queue>
#include <unordered_map>
namespace tsl {
namespace internal {
namespace {
class TFLogSinks {
public:
static TFLogSinks& Instance();
void Add(TFLogSink* sink);
void Remove(TFLogSink* sink);
std::vector<TFLogSink*> GetSinks() const;
void Send(const TFLogEntry& entry);
private:
TFLogSinks();
void SendToSink(TFLogSink& sink, const TFLogEntry& entry);
std::queue<TFLogEntry> log_entry_queue_;
static const size_t kMaxLogEntryQueueSize = 128;
mutable tsl::mutex mutex_;
std::vector<TFLogSink*> sinks_;
};
TFLogSinks::TFLogSinks() {
#ifndef NO_DEFAULT_LOGGER
static TFDefaultLogSink* default_sink = new TFDefaultLogSink();
sinks_.emplace_back(default_sink);
#endif
}
TFLogSinks& TFLogSinks::Instance() {
static TFLogSinks* instance = new TFLogSinks();
return *instance;
}
void TFLogSinks::Add(TFLogSink* sink) {
assert(sink != nullptr && "The sink must not be a nullptr");
tsl::mutex_lock lock(mutex_);
sinks_.emplace_back(sink);
if (sinks_.size() == 1) {
while (!log_entry_queue_.empty()) {
for (const auto& sink : sinks_) {
SendToSink(*sink, log_entry_queue_.front());
}
log_entry_queue_.pop();
}
}
}
void TFLogSinks::Remove(TFLogSink* sink) {
assert(sink != nullptr && "The sink must not be a nullptr");
tsl::mutex_lock lock(mutex_);
auto it = std::find(sinks_.begin(), sinks_.end(), sink);
if (it != sinks_.end()) sinks_.erase(it);
}
std::vector<TFLogSink*> TFLogSinks::GetSinks() const {
tsl::mutex_lock lock(mutex_);
return sinks_;
}
void TFLogSinks::Send(const TFLogEntry& entry) {
tsl::mutex_lock lock(mutex_);
if (sinks_.empty()) {
while (log_entry_queue_.size() >= kMaxLogEntryQueueSize) {
log_entry_queue_.pop();
}
log_entry_queue_.push(entry);
return;
}
while (!log_entry_queue_.empty()) {
for (const auto& sink : sinks_) {
SendToSink(*sink, log_entry_queue_.front());
}
log_entry_queue_.pop();
}
for (const auto& sink : sinks_) {
SendToSink(*sink, entry);
}
}
void TFLogSinks::SendToSink(TFLogSink& sink, const TFLogEntry& entry) {
sink.Send(entry);
sink.WaitTillSent();
}
class VlogFileMgr {
public:
VlogFileMgr();
~VlogFileMgr();
FILE* FilePtr() const;
private:
FILE* vlog_file_ptr;
char* vlog_file_name;
};
VlogFileMgr::VlogFileMgr() {
vlog_file_name = getenv("TF_CPP_VLOG_FILENAME");
vlog_file_ptr =
vlog_file_name == nullptr ? nullptr : fopen(vlog_file_name, "w");
if (vlog_file_ptr == nullptr) {
vlog_file_ptr = stderr;
}
}
VlogFileMgr::~VlogFileMgr() {
if (vlog_file_ptr != stderr) {
fclose(vlog_file_ptr);
}
}
FILE* VlogFileMgr::FilePtr() const { return vlog_file_ptr; }
int ParseInteger(const char* str, size_t size) {
string integer_str(str, size);
std::istringstream ss(integer_str);
int level = 0;
ss >> level;
return level;
}
int64_t LogLevelStrToInt(const char* tf_env_var_val) {
if (tf_env_var_val == nullptr) {
return 0;
}
return ParseInteger(tf_env_var_val, strlen(tf_env_var_val));
}
struct StringData {
struct Hasher {
size_t operator()(const StringData& sdata) const {
size_t hash = 5381;
const char* data = sdata.data;
for (const char* top = data + sdata.size; data < top; ++data) {
hash = ((hash << 5) + hash) + (*data);
}
return hash;
}
};
StringData() = default;
StringData(const char* data, size_t size) : data(data), size(size) {}
bool operator==(const StringData& rhs) const {
return size == rhs.size && memcmp(data, rhs.data, size) == 0;
}
const char* data = nullptr;
size_t size = 0;
};
using VmoduleMap = std::unordered_map<StringData, int, StringData::Hasher>;
VmoduleMap* VmodulesMapFromEnv() {
const char* env = getenv("TF_CPP_VMODULE");
if (env == nullptr) {
return nullptr;
}
const char* env_data = strdup(env);
VmoduleMap* result = new VmoduleMap();
while (true) {
const char* eq = strchr(env_data, '=');
if (eq == nullptr) {
break;
}
const char* after_eq = eq + 1;
const char* comma = strchr(after_eq, ',');
const char* new_env_data;
if (comma == nullptr) {
comma = strchr(after_eq, '\0');
new_env_data = comma;
} else {
new_env_data = comma + 1;
}
(*result)[StringData(env_data, eq - env_data)] = | #include "tsl/platform/logging.h"
#include <cerrno>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <memory>
#include <sstream>
#include <vector>
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/str_format.h"
#include "absl/strings/string_view.h"
#include "tsl/platform/path.h"
#include "tsl/platform/stacktrace_handler.h"
#include "tsl/platform/statusor.h"
#include "tsl/platform/test.h"
#ifdef PLATFORM_WINDOWS
#define popen _popen
#define pclose _pclose
#endif
static char* program_name;
namespace tsl {
namespace {
using ::testing::HasSubstr;
using ::testing::Not;
TEST(Logging, Log) {
LOG(INFO) << "Hello";
LOG(INFO) << "Another log message";
LOG(ERROR) << "Error message";
VLOG(1) << "A VLOG message";
VLOG(2) << "A higher VLOG message";
DVLOG(1) << "A DVLOG message";
DVLOG(2) << "A higher DVLOG message";
}
TEST(Logging, CheckChecks) {
CHECK(true);
CHECK(7 > 5);
string a("abc");
string b("xyz");
CHECK_EQ(a, a);
CHECK_NE(a, b);
CHECK_EQ(3, 3);
CHECK_NE(4, 3);
CHECK_GT(4, 3);
CHECK_GE(3, 3);
CHECK_LT(2, 3);
CHECK_LE(2, 3);
DCHECK(true);
DCHECK(7 > 5);
DCHECK_EQ(a, a);
DCHECK_NE(a, b);
DCHECK_EQ(3, 3);
DCHECK_NE(4, 3);
DCHECK_GT(4, 3);
DCHECK_GE(3, 3);
DCHECK_LT(2, 3);
DCHECK_LE(2, 3);
}
TEST(LoggingDeathTest, FailedChecks) {
string a("abc");
string b("xyz");
const char* p_const = "hello there";
const char* p_null_const = nullptr;
char mybuf[10];
char* p_non_const = mybuf;
char* p_null = nullptr;
CHECK_NOTNULL(p_const);
CHECK_NOTNULL(p_non_const);
ASSERT_DEATH(CHECK(false), "false");
ASSERT_DEATH(CHECK(9 < 7), "9 < 7");
ASSERT_DEATH(CHECK_EQ(a, b), "a == b");
ASSERT_DEATH(CHECK_EQ(3, 4), "3 == 4");
ASSERT_DEATH(CHECK_NE(3, 3), "3 != 3");
ASSERT_DEATH(CHECK_GT(2, 3), "2 > 3");
ASSERT_DEATH(CHECK_GE(2, 3), "2 >= 3");
ASSERT_DEATH(CHECK_LT(3, 2), "3 < 2");
ASSERT_DEATH(CHECK_LE(3, 2), "3 <= 2");
ASSERT_DEATH(CHECK(false), "false");
ASSERT_DEATH(printf("%s", CHECK_NOTNULL(p_null)), "Must be non NULL");
ASSERT_DEATH(printf("%s", CHECK_NOTNULL(p_null_const)), "Must be non NULL");
#ifndef NDEBUG
ASSERT_DEATH(DCHECK(9 < 7), "9 < 7");
ASSERT_DEATH(DCHECK(9 < 7), "9 < 7");
ASSERT_DEATH(DCHECK_EQ(a, b), "a == b");
ASSERT_DEATH(DCHECK_EQ(3, 4), "3 == 4");
ASSERT_DEATH(DCHECK_NE(3, 3), "3 != 3");
ASSERT_DEATH(DCHECK_GT(2, 3), "2 > 3");
ASSERT_DEATH(DCHECK_GE(2, 3), "2 >= 3");
ASSERT_DEATH(DCHECK_LT(3, 2), "3 < 2");
ASSERT_DEATH(DCHECK_LE(3, 2), "3 <= 2");
#endif
}
TEST(InternalLogString, Basic) {
internal::LogString(__FILE__, __LINE__, INFO, "Hello there");
}
class TestSink : public TFLogSink {
public:
void Send(const TFLogEntry& entry) override {
ss_ << entry.text_message() << std::endl;
}
std::string Get() const { return ss_.str(); }
private:
std::stringstream ss_;
};
TEST(LogSinkTest, testLogSinks) {
const int sinks_initial_size = TFGetLogSinks().size();
TestSink sink;
TFAddLogSink(&sink);
EXPECT_EQ(TFGetLogSinks().size(), sinks_initial_size + 1);
LOG(INFO) << "Foo";
LOG(INFO) << "Bar";
EXPECT_EQ(sink.Get(), "Foo\nBar\n");
TFRemoveLogSink(&sink);
EXPECT_EQ(TFGetLogSinks().size(), sinks_initial_size);
}
std::string ReadFromFilePointer(FILE* fp) {
std::string result;
while (!feof(fp)) {
char buf[512];
size_t len = fread(buf, sizeof(buf[0]), 512, fp);
result.append(buf, len);
}
return result;
}
absl::StatusOr<std::string> ReadFromFile(const std::string& filename) {
std::shared_ptr<FILE> fp(fopen(filename.c_str(), "r"), fclose);
if (fp == nullptr) {
return absl::ErrnoToStatus(errno,
absl::StrFormat("Cannot fopen '%s'", filename));
}
return ReadFromFilePointer(fp.get());
}
class SubcommandTest : public ::testing::Test {
public:
static constexpr absl::string_view kLogVLog = "log_and_vlog";
static bool IsSubcommand(absl::string_view subcommand) {
return subcommand == kLogVLog;
}
static int Run(absl::string_view subcommand) {
CHECK_EQ(subcommand, kLogVLog);
LOG(INFO) << "LOG INFO";
LOG(WARNING) << "LOG WARNING";
LOG(ERROR) << "LOG ERROR";
LOG(INFO) << absl::StrFormat("VLOG_IS_ON(1)? %d", VLOG_IS_ON(1));
LOG(INFO) << absl::StrFormat("VLOG_IS_ON(2)? %d", VLOG_IS_ON(2));
LOG(INFO) << absl::StrFormat("VLOG_IS_ON(3)? %d", VLOG_IS_ON(3));
VLOG(1) << "VLevel 1";
VLOG(2) << "VLevel 2";
VLOG(3) << "VLevel 3";
return EXIT_SUCCESS;
}
protected:
absl::StatusOr<std::string> CaptureOutput(const char* invocation) {
std::shared_ptr<FILE> fp(popen(invocation, "r"), pclose);
if (fp == nullptr) {
return absl::ErrnoToStatus(
errno, absl::StrFormat("Cannot popen '%s'", invocation));
}
return ReadFromFilePointer(fp.get());
}
};
TEST_F(SubcommandTest, LogDefaultTest) {
std::string command = absl::StrFormat("%s %s", program_name, kLogVLog);
#if defined(PLATFORM_GOOGLE)
command += " --alsologtostderr";
#endif
command += " 2>&1";
TF_ASSERT_OK_AND_ASSIGN(std::string out, CaptureOutput(command.c_str()));
EXPECT_THAT(out, HasSubstr("LOG INFO"));
EXPECT_THAT(out, HasSubstr("LOG WARNING"));
EXPECT_THAT(out, HasSubstr("LOG ERROR"));
EXPECT_THAT(out, HasSubstr("VLOG_IS_ON(1)? 0"));
EXPECT_THAT(out, HasSubstr("VLOG_IS_ON(2)? 0"));
EXPECT_THAT(out, HasSubstr("VLOG_IS_ON(3)? 0"));
}
TEST_F(SubcommandTest, MinLogLevelTest) {
std::string command = absl::StrFormat("%s %s", program_name, kLogVLog);
#if defined(PLATFORM_GOOGLE)
command += " --minloglevel=1 --alsologtostderr";
#elif defined(PLATFORM_WINDOWS)
command = absl::StrFormat("set TF_CPP_MIN_LOG_LEVEL=1 && %s", command);
#else
command = absl::StrFormat("TF_CPP_MIN_LOG_LEVEL=1 %s", command);
#endif
command += " 2>&1";
TF_ASSERT_OK_AND_ASSIGN(std::string out, CaptureOutput(command.c_str()));
EXPECT_THAT(out, Not(HasSubstr("LOG INFO")));
EXPECT_THAT(out, HasSubstr("LOG WARNING"));
EXPECT_THAT(out, HasSubstr("LOG ERROR"));
}
TEST_F(SubcommandTest, VLogDefaultTest) {
std::string command = absl::StrFormat("%s %s", program_name, kLogVLog);
#if defined(PLATFORM_GOOGLE)
command += " --alsologtostderr";
#endif
command += " 2>&1";
TF_ASSERT_OK_AND_ASSIGN(std::string out, CaptureOutput(command.c_str()));
EXPECT_THAT(out, Not(HasSubstr("VLevel 1")));
EXPECT_THAT(out, Not(HasSubstr("VLevel 2")));
EXPECT_THAT(out, Not(HasSubstr("VLevel 3")));
}
TEST_F(SubcommandTest, MaxVLogLevelTest) {
std::string command = absl::StrFormat("%s %s", program_name, kLogVLog);
#if defined(PLATFORM_GOOGLE)
command += " --v=2 --alsologtostderr";
#elif defined(PLATFORM_WINDOWS)
command = absl::StrFormat("set TF_CPP_MAX_VLOG_LEVEL=2 && %s", command);
#else
command = absl::StrFormat("TF_CPP_MAX_VLOG_LEVEL=2 %s", command);
#endif
command += " 2>&1";
TF_ASSERT_OK_AND_ASSIGN(std::string out, CaptureOutput(command.c_str()));
EXPECT_THAT(out, HasSubstr("VLevel 1"));
EXPECT_THAT(out, HasSubstr("VLevel 2"));
EXPECT_THAT(out, Not(HasSubstr("VLevel 3")));
EXPECT_THAT(out, HasSubstr("VLOG_IS_ON(1)? 1"));
EXPECT_THAT(out, HasSubstr("VLOG_IS_ON(2)? 1"));
EXPECT_THAT(out, HasSubstr("VLOG_IS_ON(3)? 0"));
}
TEST_F(SubcommandTest, VModuleTest) {
std::string command = absl::StrFormat("%s %s", program_name, kLogVLog);
#if defined(PLATFORM_GOOGLE)
command += " --vmodule=logging_test=2,shoobadooba=3 --alsologtostderr";
#elif defined(PLATFORM_WINDOWS)
command = absl::StrFormat(
"set TF_CPP_VMODULE=logging_test=2,shoobadooba=3 && %s", command);
#else
command = absl::StrFormat("TF_CPP_VMODULE=logging_test=2,shoobadooba=3 %s",
command);
#endif
command += " 2>&1";
TF_ASSERT_OK_AND_ASSIGN(std::string out, CaptureOutput(command.c_str()));
EXPECT_THAT(out, HasSubstr("VLevel 1"));
EXPECT_THAT(out, HasSubstr("VLevel 2"));
EXPECT_THAT(out, Not(HasSubstr("VLevel 3")));
EXPECT_THAT(out, HasSubstr("VLOG_IS_ON(1)? 1"));
EXPECT_THAT(out, HasSubstr("VLOG_IS_ON(2)? 1"));
EXPECT_THAT(out, HasSubstr("VLOG_IS_ON(3)? 0"));
}
TEST_F(SubcommandTest, VLogFilenameTest) {
#if defined(PLATFORM_GOOGLE)
constexpr bool kVLogFilenameEnvVarIsSupported = false;
#else
constexpr bool kVLogFilenameEnvVarIsSupported = true;
#endif
if (!kVLogFilenameEnvVarIsSupported) {
GTEST_SKIP() << "Not supported on this platform";
}
std::string command = absl::StrFormat("%s %s", program_name, kLogVLog);
std::string filename = io::GetTempFilename("logging_test");
#if defined(PLATFORM_WINDOWS)
command = absl::StrFormat(
"set TF_CPP_VLOG_FILENAME=%s && set TF_CPP_MAX_VLOG_LEVEL=1 && %s",
filename, command);
#else
command = absl::StrFormat(
"TF_CPP_VLOG_FILENAME=%s TF_CPP_MAX_VLOG_LEVEL=1 %s", filename, command);
#endif
command += " 2>&1";
TF_ASSERT_OK_AND_ASSIGN(std::string out, CaptureOutput(command.c_str()));
EXPECT_THAT(out, Not(HasSubstr("LOG INFO")));
EXPECT_THAT(out, Not(HasSubstr("LOG WARNING")));
EXPECT_THAT(out, Not(HasSubstr("LOG ERROR")));
EXPECT_THAT(out, Not(HasSubstr("VLOG_IS_ON(1)?")));
EXPECT_THAT(out, Not(HasSubstr("VLOG_IS_ON(2)?")));
EXPECT_THAT(out, Not(HasSubstr("VLOG_IS_ON(3)?")));
EXPECT_THAT(out, Not(HasSubstr("VLevel 1")));
EXPECT_THAT(out, Not(HasSubstr("VLevel 2")));
EXPECT_THAT(out, Not(HasSubstr("VLevel 3")));
TF_ASSERT_OK_AND_ASSIGN(std::string log_file, ReadFromFile(filename));
EXPECT_THAT(log_file, HasSubstr("LOG INFO"));
EXPECT_THAT(log_file, HasSubstr("LOG WARNING"));
EXPECT_THAT(log_file, HasSubstr("LOG ERROR"));
EXPECT_THAT(log_file, HasSubstr("VLOG_IS_ON(1)"));
EXPECT_THAT(log_file, HasSubstr("VLOG_IS_ON(2)"));
EXPECT_THAT(log_file, HasSubstr("VLOG_IS_ON(3)"));
EXPECT_THAT(log_file, HasSubstr("VLevel 1"));
EXPECT_THAT(log_file, Not(HasSubstr("VLevel 2")));
EXPECT_THAT(log_file, Not(HasSubstr("VLevel 3")));
}
}
}
GTEST_API_ int main(int argc, char** argv) {
tsl::testing::InstallStacktraceHandler();
testing::InitGoogleTest(&argc, argv);
program_name = argv[0];
if (argc >= 2 && tsl::SubcommandTest::IsSubcommand(argv[1])) {
return tsl::SubcommandTest::Run(argv[1]);
}
return RUN_ALL_TESTS();
} |
2,621 | cpp | google/tsl | unbounded_work_queue | tsl/platform/default/unbounded_work_queue.cc | tsl/platform/unbounded_work_queue_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_DEFAULT_UNBOUNDED_WORK_QUEUE_H_
#define TENSORFLOW_TSL_PLATFORM_DEFAULT_UNBOUNDED_WORK_QUEUE_H_
#include <deque>
#include <memory>
#include <vector>
#include "tsl/platform/env.h"
#include "tsl/platform/mutex.h"
#include "tsl/platform/notification.h"
namespace tsl {
class UnboundedWorkQueue {
public:
UnboundedWorkQueue(Env* env, const string& thread_name,
const ThreadOptions& thread_options = {});
~UnboundedWorkQueue();
using WorkFunction = std::function<void()>;
void Schedule(WorkFunction fn);
private:
void PooledThreadFunc();
Env* const env_;
const string thread_name_;
const ThreadOptions thread_options_;
mutex work_queue_mu_;
condition_variable work_queue_cv_ TF_GUARDED_BY(work_queue_mu_);
size_t num_idle_threads_ TF_GUARDED_BY(work_queue_mu_) = 0;
bool cancelled_ TF_GUARDED_BY(work_queue_mu_) = false;
std::deque<WorkFunction> work_queue_ TF_GUARDED_BY(work_queue_mu_);
mutex thread_pool_mu_;
std::vector<std::unique_ptr<Thread>> thread_pool_
TF_GUARDED_BY(thread_pool_mu_);
};
}
#endif
#include "tsl/platform/default/unbounded_work_queue.h"
#include "absl/memory/memory.h"
#include "tsl/platform/env.h"
#include "tsl/platform/mutex.h"
#include "tsl/platform/numa.h"
namespace tsl {
UnboundedWorkQueue::UnboundedWorkQueue(Env* env, const string& thread_name,
const ThreadOptions& thread_options)
: env_(env), thread_name_(thread_name), thread_options_(thread_options) {}
UnboundedWorkQueue::~UnboundedWorkQueue() {
{
mutex_lock l(work_queue_mu_);
cancelled_ = true;
work_queue_cv_.notify_all();
if (!work_queue_.empty()) {
LOG(ERROR) << "UnboundedWorkQueue named \"" << thread_name_ << "\" was "
<< "deleted with pending work in its queue. This may indicate "
<< "a potential use-after-free bug.";
}
}
{
mutex_lock l(thread_pool_mu_);
thread_pool_.clear();
}
}
void UnboundedWorkQueue::Schedule(WorkFunction fn) {
mutex_lock l(work_queue_mu_);
work_queue_.push_back(std::move(fn));
work_queue_cv_.notify_one();
if (work_queue_.size() > num_idle_threads_) {
Thread* new_thread =
env_->StartThread({}, thread_name_, [this]() { PooledThreadFunc(); });
mutex_lock l(thread_pool_mu_);
thread_pool_.emplace_back(new_thread);
}
}
void UnboundedWorkQueue::PooledThreadFunc() {
if (thread_options_.numa_node != tsl::port::kNUMANoAffinity) {
tsl::port::NUMASetThreadNodeAffinity(thread_options_.numa_node);
}
while (true) {
WorkFunction fn;
{
mutex_lock l(work_queue_mu_);
++num_idle_threads_;
while (!cancelled_ && work_queue_.empty()) {
work_queue_cv_.wait(l);
}
if (cancelled_) {
return;
}
fn = std::move(work_queue_.front());
work_queue_.pop_front();
--num_idle_threads_;
}
fn();
}
}
} | #include "tsl/platform/unbounded_work_queue.h"
#include "absl/memory/memory.h"
#include "tsl/platform/random.h"
#include "tsl/platform/blocking_counter.h"
#include "tsl/platform/env.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace {
class UnboundedWorkQueueTest : public ::testing::Test {
protected:
UnboundedWorkQueueTest()
: work_queue_(
absl::make_unique<UnboundedWorkQueue>(Env::Default(), "test")) {}
~UnboundedWorkQueueTest() override = default;
void RunMultipleCopiesOfClosure(const int num_closures,
std::function<void()> fn) {
for (int i = 0; i < num_closures; ++i) {
work_queue_->Schedule([this, fn]() {
fn();
mutex_lock l(mu_);
++closure_count_;
cond_var_.notify_all();
});
}
}
void BlockUntilClosuresDone(const int num_closures) {
mutex_lock l(mu_);
while (closure_count_ < num_closures) {
cond_var_.wait(l);
}
}
void ResetQueue() { work_queue_.reset(); }
int NumClosuresExecuted() {
mutex_lock l(mu_);
return closure_count_;
}
private:
mutex mu_;
int closure_count_ TF_GUARDED_BY(mu_) = 0;
condition_variable cond_var_;
std::unique_ptr<UnboundedWorkQueue> work_queue_;
};
TEST_F(UnboundedWorkQueueTest, SingleClosure) {
constexpr int num_closures = 1;
RunMultipleCopiesOfClosure(num_closures, []() {});
BlockUntilClosuresDone(num_closures);
}
TEST_F(UnboundedWorkQueueTest, MultipleClosures) {
constexpr int num_closures = 10;
RunMultipleCopiesOfClosure(num_closures, []() {});
BlockUntilClosuresDone(num_closures);
}
TEST_F(UnboundedWorkQueueTest, MultipleClosuresSleepingRandomly) {
constexpr int num_closures = 1000;
RunMultipleCopiesOfClosure(num_closures, []() {
Env::Default()->SleepForMicroseconds(random::New64() % 10);
});
BlockUntilClosuresDone(num_closures);
}
TEST_F(UnboundedWorkQueueTest, NestedClosures) {
constexpr int num_closures = 10;
RunMultipleCopiesOfClosure(num_closures, [=]() {
RunMultipleCopiesOfClosure(num_closures, []() {});
});
BlockUntilClosuresDone(num_closures * num_closures + num_closures);
}
TEST_F(UnboundedWorkQueueTest, RacyDestructor) {
constexpr int num_closures = 100;
RunMultipleCopiesOfClosure(num_closures, []() {});
ResetQueue();
EXPECT_LE(NumClosuresExecuted(), num_closures);
}
}
} |
2,622 | cpp | google/tsl | mutex | tsl/platform/default/mutex.cc | tsl/platform/mutex_test.cc | #ifndef TENSORFLOW_TSL_PLATFORM_DEFAULT_MUTEX_H_
#define TENSORFLOW_TSL_PLATFORM_DEFAULT_MUTEX_H_
namespace tsl {
namespace internal {
std::cv_status wait_until_system_clock(
CVData *cv_data, MuData *mu_data,
const std::chrono::system_clock::time_point timeout_time);
}
template <class Rep, class Period>
std::cv_status condition_variable::wait_for(
mutex_lock &lock, std::chrono::duration<Rep, Period> dur) {
return tsl::internal::wait_until_system_clock(
&this->cv_, &lock.mutex()->mu_, std::chrono::system_clock::now() + dur);
}
}
#endif
#include "tsl/platform/mutex.h"
#include <time.h>
#include "nsync_cv.h"
#include "nsync_mu.h"
#include "nsync_mu_wait.h"
#include "nsync_time.h"
namespace tsl {
static_assert(sizeof(nsync::nsync_mu) <= sizeof(internal::MuData),
"tsl::internal::MuData needs to be bigger");
static inline nsync::nsync_mu *mu_cast(internal::MuData *mu) {
return reinterpret_cast<nsync::nsync_mu *>(mu);
}
static inline const nsync::nsync_mu *mu_cast(const internal::MuData *mu) {
return reinterpret_cast<const nsync::nsync_mu *>(mu);
}
mutex::mutex() { nsync::nsync_mu_init(mu_cast(&mu_)); }
void mutex::lock() { nsync::nsync_mu_lock(mu_cast(&mu_)); }
bool mutex::try_lock() { return nsync::nsync_mu_trylock(mu_cast(&mu_)) != 0; };
void mutex::unlock() { nsync::nsync_mu_unlock(mu_cast(&mu_)); }
void mutex::assert_held() const TF_ASSERT_EXCLUSIVE_LOCK() {
nsync::nsync_mu_assert_held(mu_cast(&mu_));
}
void mutex::lock_shared() { nsync::nsync_mu_rlock(mu_cast(&mu_)); }
bool mutex::try_lock_shared() {
return nsync::nsync_mu_rtrylock(mu_cast(&mu_)) != 0;
};
void mutex::unlock_shared() { nsync::nsync_mu_runlock(mu_cast(&mu_)); }
void mutex::assert_held_shared() const TF_ASSERT_SHARED_LOCK() {
nsync::nsync_mu_rassert_held(mu_cast(&mu_));
}
static int EvaluateCondition(const void *vcond) {
return static_cast<int>(static_cast<const Condition *>(vcond)->Eval());
}
void mutex::Await(const Condition &cond) {
nsync::nsync_mu_wait(mu_cast(&mu_), &EvaluateCondition, &cond, nullptr);
}
bool mutex::AwaitWithDeadline(const Condition &cond, uint64 abs_deadline_ns) {
time_t seconds = abs_deadline_ns / (1000 * 1000 * 1000);
nsync::nsync_time abs_time = nsync::nsync_time_s_ns(
seconds, abs_deadline_ns - seconds * (1000 * 1000 * 1000));
return nsync::nsync_mu_wait_with_deadline(mu_cast(&mu_), &EvaluateCondition,
&cond, nullptr, abs_time,
nullptr) == 0;
}
static_assert(sizeof(nsync::nsync_cv) <= sizeof(internal::CVData),
"tsl::internal::CVData needs to be bigger");
static inline nsync::nsync_cv *cv_cast(internal::CVData *cv) {
return reinterpret_cast<nsync::nsync_cv *>(cv);
}
condition_variable::condition_variable() {
nsync::nsync_cv_init(cv_cast(&cv_));
}
void condition_variable::wait(mutex_lock &lock) {
nsync::nsync_cv_wait(cv_cast(&cv_), mu_cast(&lock.mutex()->mu_));
}
void condition_variable::notify_one() { nsync::nsync_cv_signal(cv_cast(&cv_)); }
void condition_variable::notify_all() {
nsync::nsync_cv_broadcast(cv_cast(&cv_));
}
namespace internal {
std::cv_status wait_until_system_clock(
CVData *cv_data, MuData *mu_data,
const std::chrono::system_clock::time_point timeout_time) {
int r = nsync::nsync_cv_wait_with_deadline(cv_cast(cv_data), mu_cast(mu_data),
timeout_time, nullptr);
return r ? std::cv_status::timeout : std::cv_status::no_timeout;
}
}
} | #include "tsl/platform/mutex.h"
#include "tsl/platform/test.h"
#include "tsl/platform/threadpool.h"
namespace tsl {
namespace {
class MutexTest : public ::testing::Test {
protected:
mutex_lock GetLock() TF_NO_THREAD_SAFETY_ANALYSIS {
return mutex_lock{mu_};
}
tf_shared_lock GetSharedLock() TF_NO_THREAD_SAFETY_ANALYSIS {
return tf_shared_lock{mu_};
}
bool test_try_lock() {
bool test = mu_.try_lock();
if (test) mu_.unlock();
return test;
}
bool test_try_lock_shared() {
bool test = mu_.try_lock_shared();
if (test) mu_.unlock_shared();
return test;
}
mutex mu_;
};
TEST_F(MutexTest, MovableMutexLockTest) {
EXPECT_TRUE(test_try_lock());
{
mutex_lock lock = GetLock();
EXPECT_FALSE(test_try_lock());
EXPECT_FALSE(test_try_lock_shared());
}
EXPECT_TRUE(test_try_lock());
}
TEST_F(MutexTest, SharedMutexLockTest) {
EXPECT_TRUE(test_try_lock());
{
tf_shared_lock lock = GetSharedLock();
EXPECT_FALSE(test_try_lock());
EXPECT_TRUE(test_try_lock_shared());
}
EXPECT_TRUE(test_try_lock());
}
TEST(ConditionVariableTest, WaitWithPredicate) {
constexpr int kNumThreads = 4;
mutex mu;
condition_variable cv;
bool ready = false;
int count = 0;
tsl::thread::ThreadPool pool(Env::Default(),
"condition_variable_test_wait_with_predicate",
kNumThreads);
for (int i = 0; i < kNumThreads; ++i) {
pool.Schedule([&mu, &cv, &ready, &count]() {
mutex_lock lock(mu);
cv.wait(lock, [&ready] { return ready; });
++count;
cv.notify_one();
});
}
{
mutex_lock lock(mu);
EXPECT_EQ(count, 0);
}
{
mutex_lock lock(mu);
ready = true;
cv.notify_all();
}
{
mutex_lock lock(mu);
cv.wait(lock, [&count, kNumThreads] { return count == kNumThreads; });
EXPECT_EQ(count, kNumThreads);
}
}
TEST(ConditionVariableTest, WaitWithTruePredicateDoesntBlock) {
mutex mu;
mutex_lock lock(mu);
condition_variable cv;
cv.wait(lock, [] { return true; });
EXPECT_TRUE(static_cast<bool>(lock));
}
}
} |
2,623 | cpp | google/tsl | parse_annotation | tsl/profiler/utils/parse_annotation.cc | tsl/profiler/utils/parse_annotation_test.cc | #ifndef TENSORFLOW_TSL_PROFILER_UTILS_PARSE_ANNOTATION_H_
#define TENSORFLOW_TSL_PROFILER_UTILS_PARSE_ANNOTATION_H_
#include <vector>
#include "absl/strings/string_view.h"
namespace tsl {
namespace profiler {
struct Annotation {
absl::string_view name;
struct Metadata {
absl::string_view key;
absl::string_view value;
};
std::vector<Metadata> metadata;
};
Annotation ParseAnnotation(absl::string_view annotation);
inline bool HasMetadata(absl::string_view annotation) {
constexpr char kUserMetadataMarker = '#';
return !annotation.empty() && annotation.back() == kUserMetadataMarker;
}
std::vector<Annotation> ParseAnnotationStack(
absl::string_view annotation_stack);
}
}
#endif
#include "tsl/profiler/utils/parse_annotation.h"
#include <stack>
#include <string>
#include <utility>
#include <vector>
#include "absl/strings/ascii.h"
#include "absl/strings/str_split.h"
#include "absl/strings/string_view.h"
namespace tsl {
namespace profiler {
namespace {
std::vector<absl::string_view> SplitNameAndMetadata(
absl::string_view annotation) {
std::vector<absl::string_view> parts;
if (!HasMetadata(annotation)) {
parts.emplace_back(annotation);
} else {
annotation.remove_suffix(1);
parts = absl::StrSplit(annotation, '#');
if (parts.size() > 2) {
parts.resize(2);
}
}
while (parts.size() < 2) {
parts.emplace_back();
}
return parts;
}
std::vector<absl::string_view> SplitPairs(absl::string_view metadata) {
std::vector<absl::string_view> key_value_pairs;
std::stack<char> quotes;
size_t start = 0, end = 0;
for (; end < metadata.size(); ++end) {
char ch = metadata[end];
switch (ch) {
case '\"':
case '\'':
if (quotes.empty() || quotes.top() != ch) {
quotes.push(ch);
} else {
quotes.pop();
}
break;
case '{':
case '(':
case '[':
quotes.push(ch);
break;
case '}':
if (!quotes.empty() && quotes.top() == '{') {
quotes.pop();
}
break;
case ')':
if (!quotes.empty() && quotes.top() == '(') {
quotes.pop();
}
break;
case ']':
if (!quotes.empty() && quotes.top() == '[') {
quotes.pop();
}
break;
case ',':
if (quotes.empty()) {
if (end - start > 1) {
key_value_pairs.emplace_back(metadata.data() + start, end - start);
}
start = end + 1;
}
break;
}
}
if (end - start > 1) {
key_value_pairs.emplace_back(metadata.data() + start, end - start);
}
return key_value_pairs;
}
std::vector<std::pair<absl::string_view, absl::string_view>> ParseMetadata(
absl::string_view metadata) {
std::vector<std::pair<absl::string_view, absl::string_view>> key_values;
for (absl::string_view pair : SplitPairs(metadata)) {
std::vector<absl::string_view> parts =
absl::StrSplit(pair, absl::MaxSplits('=', 1));
if (parts.size() == 2) {
absl::string_view key = absl::StripAsciiWhitespace(parts[0]);
absl::string_view value = absl::StripAsciiWhitespace(parts[1]);
if (!key.empty() && !value.empty()) {
key_values.push_back({key, value});
}
}
}
return key_values;
}
}
Annotation ParseAnnotation(absl::string_view annotation) {
Annotation result;
std::vector<absl::string_view> parts = SplitNameAndMetadata(annotation);
if (!parts.empty()) {
result.name = absl::StripAsciiWhitespace(parts[0]);
for (const auto& key_value : ParseMetadata(parts[1])) {
result.metadata.push_back({key_value.first, key_value.second});
}
}
return result;
}
std::vector<Annotation> ParseAnnotationStack(
absl::string_view annotation_stack) {
std::vector<Annotation> annotations;
const std::string kAnnotationDelimiter = "::";
for (absl::string_view annotation : absl::StrSplit(
annotation_stack, kAnnotationDelimiter, absl::SkipEmpty())) {
annotations.emplace_back(ParseAnnotation(annotation));
}
return annotations;
}
}
} | #include "tsl/profiler/utils/parse_annotation.h"
#include <vector>
#include "absl/strings/string_view.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace profiler {
namespace {
TEST(ParseAnnotationStackTest, EmptyAnnotationStackTest) {
std::vector<Annotation> annotations = ParseAnnotationStack("");
ASSERT_TRUE(annotations.empty());
}
TEST(ParseAnnotationStackTest, SingleAnnotationStackTest) {
std::vector<Annotation> annotations = ParseAnnotationStack("name");
ASSERT_FALSE(annotations.empty());
EXPECT_EQ(annotations.back().name, "name");
EXPECT_TRUE(annotations.back().metadata.empty());
}
TEST(ParseAnnotationStackTest, MultiLevelAnnotationStackTest) {
std::vector<Annotation> annotations = ParseAnnotationStack("outer::inner");
ASSERT_EQ(annotations.size(), 2);
EXPECT_EQ(annotations.front().name, "outer");
EXPECT_TRUE(annotations.front().metadata.empty());
EXPECT_EQ(annotations.back().name, "inner");
EXPECT_TRUE(annotations.back().metadata.empty());
}
TEST(ParseAnnotationTest, EmptyAnnotationTest) {
Annotation annotation = ParseAnnotation("");
EXPECT_TRUE(annotation.name.empty());
EXPECT_TRUE(annotation.metadata.empty());
}
TEST(ParseAnnotationTest, SimpleNameTest) {
Annotation annotation = ParseAnnotation("name");
EXPECT_EQ(annotation.name, "name");
EXPECT_TRUE(annotation.metadata.empty());
}
TEST(ParseAnnotationTest, SimpleNameWithWhitespaceTest) {
Annotation annotation = ParseAnnotation("name ");
EXPECT_EQ(annotation.name, "name");
EXPECT_TRUE(annotation.metadata.empty());
}
TEST(ParseAnnotationTest, EmptyMetadataTest) {
Annotation annotation = ParseAnnotation("name#");
EXPECT_EQ(annotation.name, "name");
EXPECT_TRUE(annotation.metadata.empty());
annotation = ParseAnnotation("name1##");
EXPECT_EQ(annotation.name, "name1");
EXPECT_TRUE(annotation.metadata.empty());
annotation = ParseAnnotation("name2###");
EXPECT_EQ(annotation.name, "name2");
EXPECT_TRUE(annotation.metadata.empty());
}
TEST(ParseAnnotationTest, SingleMetadataTest) {
Annotation annotation = ParseAnnotation("name#key=value#");
EXPECT_EQ(annotation.name, "name");
ASSERT_EQ(annotation.metadata.size(), 1);
EXPECT_EQ(annotation.metadata.at(0).key, "key");
EXPECT_EQ(annotation.metadata.at(0).value, "value");
}
TEST(ParseAnnotationTest, MultipleMetadataTest) {
Annotation annotation = ParseAnnotation("name#k1=v1,k2=v2,k3=v3#");
EXPECT_EQ(annotation.name, "name");
ASSERT_EQ(annotation.metadata.size(), 3);
EXPECT_EQ(annotation.metadata.at(0).key, "k1");
EXPECT_EQ(annotation.metadata.at(0).value, "v1");
EXPECT_EQ(annotation.metadata.at(1).key, "k2");
EXPECT_EQ(annotation.metadata.at(1).value, "v2");
EXPECT_EQ(annotation.metadata.at(2).key, "k3");
EXPECT_EQ(annotation.metadata.at(2).value, "v3");
}
TEST(ParseAnnotationTest, MultipleMetadataWithWhitespaceTest) {
Annotation annotation = ParseAnnotation("name # k1 = v1, ,k2=v2 #");
EXPECT_EQ(annotation.name, "name");
ASSERT_EQ(annotation.metadata.size(), 2);
EXPECT_EQ(annotation.metadata.at(0).key, "k1");
EXPECT_EQ(annotation.metadata.at(0).value, "v1");
EXPECT_EQ(annotation.metadata.at(1).key, "k2");
EXPECT_EQ(annotation.metadata.at(1).value, "v2");
}
TEST(ParseAnnotationTest, KeyValueSeparatorTest) {
Annotation annotation = ParseAnnotation("name#=v1,k2=,k3==v3,k4=v4=#");
EXPECT_EQ(annotation.name, "name");
ASSERT_EQ(annotation.metadata.size(), 2);
EXPECT_EQ(annotation.metadata.at(0).key, "k3");
EXPECT_EQ(annotation.metadata.at(0).value, "=v3");
EXPECT_EQ(annotation.metadata.at(1).key, "k4");
EXPECT_EQ(annotation.metadata.at(1).value, "v4=");
}
TEST(ParseAnnotationTest, ExtraMetadataSeparatorTest) {
Annotation annotation = ParseAnnotation("name##k1=v1#");
EXPECT_EQ(annotation.name, "name");
EXPECT_TRUE(annotation.metadata.empty());
}
TEST(ParseAnnotationTest, QuotedMetadata) {
Annotation annotation = ParseAnnotation(
"name#k1=(v11,v12),k2=[v21,v22,v23],k3={v31,v32}, k4=\"v41,v42\","
"(k51,k52)='v51,v52'#");
EXPECT_EQ(annotation.metadata.at(0).key, "k1");
EXPECT_EQ(annotation.metadata.at(0).value, "(v11,v12)");
EXPECT_EQ(annotation.metadata.at(1).key, "k2");
EXPECT_EQ(annotation.metadata.at(1).value, "[v21,v22,v23]");
EXPECT_EQ(annotation.metadata.at(2).key, "k3");
EXPECT_EQ(annotation.metadata.at(2).value, "{v31,v32}");
EXPECT_EQ(annotation.metadata.at(3).key, "k4");
EXPECT_EQ(annotation.metadata.at(3).value, "\"v41,v42\"");
EXPECT_EQ(annotation.metadata.at(4).key, "(k51,k52)");
EXPECT_EQ(annotation.metadata.at(4).value, "'v51,v52'");
}
TEST(ParseAnnotationTest, UnmatchedQuotedMetadata) {
Annotation annotation = ParseAnnotation("name#k1=v1,k2=(v2,k3=v3#");
EXPECT_EQ(annotation.metadata.at(0).key, "k1");
EXPECT_EQ(annotation.metadata.at(0).value, "v1");
EXPECT_EQ(annotation.metadata.at(1).key, "k2");
EXPECT_EQ(annotation.metadata.at(1).value, "(v2,k3=v3");
}
}
}
} |
2,624 | cpp | google/tsl | xplane_utils | tsl/profiler/utils/xplane_utils.cc | tsl/profiler/utils/xplane_utils_test.cc | #ifndef TENSORFLOW_TSL_PROFILER_UTILS_XPLANE_UTILS_H_
#define TENSORFLOW_TSL_PROFILER_UTILS_XPLANE_UTILS_H_
#include <algorithm>
#include <cstdint>
#include <optional>
#include <vector>
#include "absl/algorithm/container.h"
#include "absl/container/flat_hash_map.h"
#include "absl/container/flat_hash_set.h"
#include "absl/strings/string_view.h"
#include "tsl/platform/types.h"
#include "tsl/profiler/protobuf/xplane.pb.h"
#include "tsl/profiler/utils/timespan.h"
#include "tsl/profiler/utils/trace_utils.h"
#include "tsl/profiler/utils/xplane_visitor.h"
namespace tsl {
namespace profiler {
inline Timespan XEventTimespan(const XEvent& event) {
return Timespan(event.offset_ps(), event.duration_ps());
}
template <typename F>
std::vector<const XPlane*> FindPlanes(const XSpace& space, const F& predicate) {
std::vector<const XPlane*> result;
for (const XPlane& plane : space.planes()) {
if (predicate(plane)) {
result.push_back(&plane);
}
}
return result;
}
template <typename F>
std::vector<XPlane*> FindMutablePlanes(XSpace* space, const F& predicate) {
std::vector<XPlane*> result;
for (XPlane& plane : *space->mutable_planes()) {
if (predicate(plane)) {
result.push_back(&plane);
}
}
return result;
}
const XPlane* FindPlaneWithName(const XSpace& space, absl::string_view name);
XPlane* FindMutablePlaneWithName(XSpace* space, absl::string_view name);
std::vector<const XPlane*> FindPlanesWithNames(
const XSpace& space, const std::vector<absl::string_view>& names);
XPlane* FindOrAddMutablePlaneWithName(XSpace* space, absl::string_view name);
std::vector<const XPlane*> FindPlanesWithPrefix(const XSpace& space,
absl::string_view prefix);
std::vector<XPlane*> FindMutablePlanesWithPrefix(XSpace* space,
absl::string_view prefix);
const XLine* FindLineWithId(const XPlane& plane, int64_t id);
std::vector<const XLine*> FindLinesWithId(const XPlane& plane, int64_t id);
const XLine* FindLineWithName(const XPlane& plane, absl::string_view name);
XStat* FindOrAddMutableStat(const XStatMetadata& stat_metadata, XEvent* event);
void RemovePlane(XSpace* space, const XPlane* plane);
void RemovePlanes(XSpace* space, const std::vector<const XPlane*>& planes);
void RemoveLine(XPlane* plane, const XLine* line);
void RemoveEvents(XLine* line,
const absl::flat_hash_set<const XEvent*>& events);
void RemoveEmptyPlanes(XSpace* space);
void RemoveEmptyLines(XPlane* plane);
template <class Compare>
void SortXLinesBy(XPlane* plane, Compare comp) {
std::sort(plane->mutable_lines()->pointer_begin(),
plane->mutable_lines()->pointer_end(), comp);
}
class XLinesComparatorByName {
public:
bool operator()(const XLine* a, const XLine* b) const {
auto& line_a = a->display_name().empty() ? a->name() : a->display_name();
auto& line_b = b->display_name().empty() ? b->name() : b->display_name();
return line_a < line_b;
}
};
void SortXPlane(XPlane* plane);
void SortXSpace(XSpace* space);
struct XEventsComparator {
bool operator()(const XEvent* a, const XEvent* b) const;
};
template <typename Event, typename Plane>
inline std::vector<Event> GetSortedEvents(Plane& plane,
bool include_derived_events = false) {
std::vector<Event> events;
plane.ForEachLine([&events, include_derived_events](auto line) {
if (!include_derived_events && IsDerivedThreadId(line.Id())) return;
line.ForEachEvent(
[&events](auto event) { events.emplace_back(std::move(event)); });
});
absl::c_sort(events);
return events;
}
void NormalizeTimestamps(XPlane* plane, uint64 start_time_ns);
void NormalizeTimestamps(XSpace* space, uint64 start_time_ns);
void MergePlanes(const XPlane& src_plane, XPlane* dst_plane);
void MergePlanes(const std::vector<const XPlane*>& src_planes,
XPlane* dst_plane);
int64_t GetStartTimestampNs(const XPlane& plane);
bool IsEmpty(const XSpace& space);
bool IsXSpaceGrouped(const XSpace& space);
void AddFlowsToXplane(int32_t host_id, bool is_host_plane, bool connect_traceme,
XPlane* plane);
uint64_t GetDevicePlaneFingerprint(const XPlane& plane);
template <typename XPlanePointerIterator>
void SortPlanesById(XPlanePointerIterator begin, XPlanePointerIterator end) {
std::sort(begin, end, [&](const XPlane* a, const XPlane* b) {
return a->id() < b->id();
});
}
class XEventContextTracker {
public:
XEventContextTracker(const XPlaneVisitor* plane, const XLine* line)
: plane_(plane), line_(line) {}
std::optional<XEventVisitor> GetContainingEvent(const Timespan& event);
std::optional<XEventVisitor> GetOverlappingEvent(const Timespan& event);
private:
const XPlaneVisitor* plane_;
const XLine* line_;
int64_t current_index_ = -1;
};
void AggregateXPlane(const XPlane& full_trace, XPlane& aggregated_trace);
bool IsCustomPlane(const XPlane& plane);
bool IsHostPlane(const XPlane& plane);
bool IsDevicePlane(const XPlane& plane);
}
}
#endif
#include "tsl/profiler/utils/xplane_utils.h"
#include <algorithm>
#include <cstdint>
#include <limits>
#include <optional>
#include <set>
#include <string>
#include <utility>
#include <vector>
#include "absl/container/flat_hash_map.h"
#include "absl/container/flat_hash_set.h"
#include "absl/log/log.h"
#include "absl/strings/match.h"
#include "absl/strings/string_view.h"
#include "xla/tsl/util/stats_calculator.h"
#include "tsl/platform/fingerprint.h"
#include "tsl/platform/types.h"
#include "tsl/profiler/lib/context_types.h"
#include "tsl/profiler/protobuf/xplane.pb.h"
#include "tsl/profiler/utils/math_utils.h"
#include "tsl/profiler/utils/tf_xplane_visitor.h"
#include "tsl/profiler/utils/timespan.h"
#include "tsl/profiler/utils/xplane_builder.h"
#include "tsl/profiler/utils/xplane_schema.h"
#include "tsl/profiler/utils/xplane_visitor.h"
namespace tsl {
namespace profiler {
namespace {
template <typename T, typename Pred>
std::vector<int> FindAll(const protobuf::RepeatedPtrField<T>& array,
const Pred& pred) {
std::vector<int> indices;
for (int i = 0; i < array.size(); ++i) {
if (pred(&array.Get(i))) indices.push_back(i);
}
return indices;
}
template <typename T, typename Pred>
int Find(const protobuf::RepeatedPtrField<T>& array, const Pred& pred) {
std::vector<int> indices = FindAll(array, pred);
if (indices.size() > 1) {
LOG(WARNING) << "Found multiple " << T().GetTypeName()
<< " when only one was expected.";
}
return indices.empty() ? -1 : indices.front();
}
template <typename T>
void RemoveAt(protobuf::RepeatedPtrField<T>* array,
const std::vector<int>& indices) {
if (indices.empty()) return;
if (array->size() == indices.size()) {
array->Clear();
return;
}
auto remove_iter = indices.begin();
int i = *(remove_iter++);
for (int j = i + 1; j < array->size(); ++j) {
if (remove_iter != indices.end() && *remove_iter == j) {
++remove_iter;
} else {
array->SwapElements(j, i++);
}
}
array->DeleteSubrange(i, array->size() - i);
}
template <typename T>
void Remove(protobuf::RepeatedPtrField<T>* array, const T* elem) {
int i = Find(*array, [elem](const T* e) { return elem == e; });
RemoveAt(array, {i});
}
template <typename T, typename Pred>
void RemoveIf(protobuf::RepeatedPtrField<T>* array, Pred&& pred) {
std::vector<int> indices = FindAll(*array, pred);
RemoveAt(array, indices);
}
void CopyEventMetadata(const XEventMetadata& src_event_metadata,
const XPlaneVisitor& src_plane,
XEventMetadata& dst_event_metadata,
XPlaneBuilder& dst_plane) {
if (dst_event_metadata.display_name().empty() &&
!src_event_metadata.display_name().empty()) {
dst_event_metadata.set_display_name(src_event_metadata.display_name());
}
if (dst_event_metadata.name().empty() && !src_event_metadata.name().empty()) {
dst_event_metadata.set_name(src_event_metadata.name());
}
if (dst_event_metadata.metadata().empty() &&
!src_event_metadata.metadata().empty()) {
dst_event_metadata.set_metadata(src_event_metadata.metadata());
}
if (dst_event_metadata.stats().empty() &&
!src_event_metadata.stats().empty()) {
XEventMetadataVisitor src_event_metadata_visitor(&src_plane,
&src_event_metadata);
src_event_metadata_visitor.ForEachStat([&](const XStatVisitor& src_stat) {
XStatMetadata& metadata =
*dst_plane.GetOrCreateStatMetadata(src_stat.Name());
XStat& dst_stat = *dst_event_metadata.add_stats();
dst_stat = src_stat.RawStat();
if (src_stat.ValueCase() == XStat::kRefValue) {
XStatMetadata& value_metadata =
*dst_plane.GetOrCreateStatMetadata(src_stat.StrOrRefValue());
dst_stat.set_ref_value(value_metadata.id());
}
dst_stat.set_metadata_id(metadata.id());
});
}
DCHECK_EQ(src_event_metadata.stats_size(), dst_event_metadata.stats_size());
}
void CopyEvent(const XEventVisitor& src_event, const XPlaneVisitor& src,
const XPlane& src_plane, int64_t time_offset_ps,
XPlaneBuilder& dst_plane, XLineBuilder& dst_line) {
XEventMetadata* dst_event_metadata =
dst_plane.GetOrCreateEventMetadata(src_event.Name());
CopyEventMetadata(*src_event.metadata(), src, *dst_event_metadata, dst_plane);
XEventBuilder dst_event = dst_line.AddEvent(*dst_event_metadata);
if (src_event.IsAggregatedEvent()) {
dst_event.SetNumOccurrences(src_event.NumOccurrences());
} else {
dst_event.SetOffsetPs(src_event.OffsetPs() + time_offset_ps);
}
dst_event.SetDurationPs(src_event.DurationPs());
src_event.ForEachStat([&](const XStatVisitor& stat) {
dst_event.AddStat(*dst_plane.GetOrCreateStatMetadata(stat.Name()),
stat.RawStat(), src_plane);
});
}
bool IsOpLineName(absl::string_view line_name) {
return line_name == kXlaOpLineName || line_name == kTensorFlowOpLineName;
}
}
const XPlane* FindPlaneWithName(const XSpace& space, absl::string_view name) {
int i = Find(space.planes(),
[name](const XPlane* plane) { return plane->name() == name; });
return (i != -1) ? &space.planes(i) : nullptr;
}
std::vector<const XPlane*> FindPlanesWithNames(
const XSpace& space, const std::vector<absl::string_view>& names) {
absl::flat_hash_set<absl::string_view> names_set(names.begin(), names.end());
std::vector<int> indices =
FindAll(space.planes(), [&names_set](const XPlane* plane) {
return names_set.contains(plane->name());
});
std::vector<const XPlane*> planes;
planes.reserve(indices.size());
for (int i : indices) {
planes.push_back(&space.planes(i));
}
return planes;
}
XPlane* FindMutablePlaneWithName(XSpace* space, absl::string_view name) {
int i = Find(space->planes(),
[name](const XPlane* plane) { return plane->name() == name; });
return (i != -1) ? space->mutable_planes(i) : nullptr;
}
XPlane* FindOrAddMutablePlaneWithName(XSpace* space, absl::string_view name) {
XPlane* plane = FindMutablePlaneWithName(space, name);
if (plane == nullptr) {
plane = space->add_planes();
plane->set_name(name.data(), name.size());
}
return plane;
}
std::vector<const XPlane*> FindPlanesWithPrefix(const XSpace& space,
absl::string_view prefix) {
return FindPlanes(space, [&](const XPlane& plane) {
return absl::StartsWith(plane.name(), prefix);
});
}
std::vector<XPlane*> FindMutablePlanesWithPrefix(XSpace* space,
absl::string_view prefix) {
return FindMutablePlanes(space, [&](XPlane& plane) {
return absl::StartsWith(plane.name(), prefix);
});
}
const XLine* FindLineWithId(const XPlane& plane, int64_t id) {
int i =
Find(plane.lines(), [id](const XLine* line) { return line->id() == id; });
return (i != -1) ? &plane.lines(i) : nullptr;
}
std::vector<const XLine*> FindLinesWithId(const XPlane& plane, int64_t id) {
std::vector<int> indices = FindAll(
plane.lines(), [id](const XLine* line) { return line->id() == id; });
std::vector<const XLine*> lines;
lines.reserve(indices.size());
for (int index : indices) {
lines.push_back(&plane.lines(index));
}
return lines;
}
const XLine* FindLineWithName(const XPlane& plane, absl::string_view name) {
int i = Find(plane.lines(),
[name](const XLine* line) { return line->name() == name; });
return (i != -1) ? &plane.lines(i) : nullptr;
}
XStat* FindOrAddMutableStat(const XStatMetadata& stat_metadata, XEvent* event) {
for (auto& stat : *event->mutable_stats()) {
if (stat.metadata_id() == stat_metadata.id()) {
return &stat;
}
}
XStat* stat = event->add_stats();
stat->set_metadata_id(stat_metadata.id());
return stat;
}
void RemovePlane(XSpace* space, const XPlane* plane) {
DCHECK(plane != nullptr);
Remove(space->mutable_planes(), plane);
}
void RemovePlanes(XSpace* space, const std::vector<const XPlane*>& planes) {
absl::flat_hash_set<const XPlane*> planes_set(planes.begin(), planes.end());
RemoveIf(space->mutable_planes(), [&planes_set](const XPlane* plane) {
return planes_set.contains(plane);
});
}
void RemoveLine(XPlane* plane, const XLine* line) {
DCHECK(line != nullptr);
Remove(plane->mutable_lines(), line);
}
void RemoveEvents(XLine* line,
const absl::flat_hash_set<const XEvent*>& events) {
RemoveIf(line->mutable_events(),
[&](const XEvent* event) { return events.contains(event); });
}
void RemoveEmptyPlanes(XSpace* space) {
RemoveIf(space->mutable_planes(),
[&](const XPlane* plane) { return plane->lines().empty(); });
}
void RemoveEmptyLines(XPlane* plane) {
RemoveIf(plane->mutable_lines(),
[&](const XLine* line) { return line->events().empty(); });
}
bool XEventsComparator::operator()(const XEvent* a, const XEvent* b) const {
return XEventTimespan(*a) < XEventTimespan(*b);
}
void SortXPlane(XPlane* plane) {
for (XLine& line : *plane->mutable_lines()) {
auto& events = *line.mutable_events();
std::sort(events.pointer_begin(), events.pointer_end(),
XEventsComparator());
}
}
void SortXSpace(XSpace* space) {
for (XPlane& plane : *space->mutable_planes()) SortXPlane(&plane);
}
void NormalizeTimestamps(XPlane* plane, uint64 start_time_ns) {
for (XLine& line : *plane->mutable_lines()) {
if (line.timestamp_ns() >= static_cast<int64_t>(start_time_ns)) {
line.set_timestamp_ns(line.timestamp_ns() - start_time_ns);
}
}
}
void NormalizeTimestamps(XSpace* space, uint64 start_time_ns) {
for (XPlane& plane : *space->mutable_planes()) {
NormalizeTimestamps(&plane, start_time_ns);
}
}
void MergePlanes(const XPlane& src_plane, XPlane* dst_plane) {
RemoveEmptyLines(dst_plane);
XPlaneVisitor src(&src_plane);
XPlaneBuilder dst(dst_plane);
src.ForEachStat([&](const XStatVisitor& stat) {
XStatMetadata* stat_metadata = dst.GetOrCreateStatMetadata(stat.Name());
dst.SetOrAddStat(*stat_metadata, stat.RawStat(), src_plane);
});
src.ForEachLine([&](const XLineVisitor& line) {
XLineBuilder dst_line = dst.GetOrCreateLine(line.Id());
int64_t time_offset_ps = 0LL;
if (dst_line.NumEvents() == 0) {
dst_line.SetTimestampNs(line.TimestampNs());
dst_line.SetName(line.Name());
dst_line.SetDisplayNameIfEmpty(line.DisplayName());
} else {
if (line.TimestampNs() <= dst_line.TimestampNs()) {
dst_line.SetTimestampNsAndAdjustEventOffsets(line.TimestampNs());
} else {
time_offset_ps =
NanoToPico(line.TimestampNs() - dst_line.TimestampNs());
}
dst_line.SetNameIfEmpty(line.Name());
}
line.ForEachEvent([&](const XEventVisitor& event) {
CopyEvent(event, src, src_plane, time_offset_ps, dst, dst_line);
});
});
}
void MergePlanes(const std::vector<const XPlane*>& src_planes,
XPlane* dst_plane) {
for (const XPlane* src_plane : src_planes) {
MergePlanes(*src_plane, dst_plane);
}
}
int64_t GetStartTimestampNs(const XPlane& plane) {
if (plane.lines().empty()) return 0LL;
int64_t plane_timestamp = std::numeric_limits<int64_t>::max();
for (const auto& line : plane.lines()) {
plane_timestamp = std::min(plane_timestamp, line.timestamp_ns());
}
return plane_timestamp;
}
bool IsEmpty(const XSpace& space) {
for (const auto& plane : space.planes()) {
for (const auto& line : plane.lines()) {
if (!line.events().empty()) {
return false;
}
}
}
return true;
}
bool IsXSpaceGrouped(const XSpace& space) {
for (const auto& plane : space.planes()) {
XPlaneVisitor xplane = tsl::profiler::CreateTfXPlaneVisitor(&plane);
const XStatMetadata* group_id_stat =
xplane.GetStatMetadataByType(StatType::kGroupId);
if (group_id_stat) return true;
}
return false;
}
void AddFlowsToXplane(int32_t host_id, bool is_host_plane, bool connect_traceme,
XPlane* xplane) {
if (!xplane) return;
XPlaneBuilder plane(xplane);
XStatMetadata* correlation_id_stats_metadata =
plane.GetStatMetadata(GetStatTypeStr(StatType::kCorrelationId));
XStatMetadata* producer_type_stats_metadata =
plane.GetStatMetadata(GetStatTypeStr(StatType::kProducerType));
XStatMetadata* consumer_type_stats_metadata =
plane.GetStatMetadata(GetStatTypeStr(StatType::kConsumerType));
XStatMetadata* producer_id_stats_metadata =
plane.GetStatMetadata(GetStatTypeStr(StatType::kProducerId));
XStatMetadata* consumer_id_stats_metadata =
plane.GetStatMetadata(GetStatTypeStr(StatType::kConsumerId));
XStatMetadata* flow_stats_metadata =
plane.GetOrCreateStatMetadata(GetStatTypeStr(StatType::kFlow));
XFlow::FlowDirection direction = is_host_plane
? XFlow::FlowDirection::kFlowOut
: XFlow::FlowDirection::kFlowIn;
plane.ForEachLine([&](XLineBuilder line) {
line.ForEachEvent([&](XEventBuilder event) {
std::optional<uint64_t> correlation_id;
std::optional<uint64_t> producer_type;
std::optional<uint64_t> consumer_type;
std::optional<uint64_t> producer_id;
std::optional<uint64_t> consumer_id;
event.ForEachStat([&](XStat* stat) {
if (correlation_id_stats_metadata &&
stat->metadata_id() == correlation_id_stats_metadata->id()) {
correlation_id = stat->uint64_value();
} else if (connect_traceme) {
if (producer_type_stats_metadata &&
stat->metadata_id() == producer_type_stats_metadata->id()) {
producer_type = XStatsBuilder<XPlane>::IntOrUintValue(*stat);
} else if (consumer_type_stats_metadata &&
stat->metadata_id() ==
consumer_type_stats_metadata->id()) {
consumer_type = XStatsBuilder<XPlane>::IntOrUintValue(*stat);
} else if (producer_id_stats_metadata &&
stat->metadata_id() == producer_id_stats_metadata->id()) {
producer_id = XStatsBuilder<XPlane>::IntOrUintValue(*stat);
} else if (consumer_id_stats_metadata &&
stat->metadata_id() == consumer_id_stats_metadata->id()) {
consumer_id = XStatsBuilder<XPlane>::IntOrUintValue(*stat);
}
}
});
if (correlation_id) {
XFlow flow(XFlow::GetFlowId(host_id, *correlation_id), direction,
ContextType::kGpuLaunch);
event.AddStatValue(*flow_stats_metadata, flow.ToStatValue());
}
if (connect_traceme) {
if (producer_type && producer_id) {
auto context_type = GetSafeContextType(*producer_type);
XFlow flow(XFlow::GetFlowId(host_id, *producer_id, context_type),
XFlow::FlowDirection::kFlowOut, context_type);
event.AddStatValue(*flow_stats_metadata, flow.ToStatValue());
}
if (consumer_type && consumer_id) {
auto context_type = GetSafeContextType(*consumer_type);
XFlow flow(XFlow::GetFlowId(host_id, *consumer_id, context_type),
XFlow::FlowDirection::kFlowIn, context_type);
event.AddStatValue(*flow_stats_metadata, flow.ToStatValue());
}
}
});
});
}
uint64_t GetDevicePlaneFingerprint(const XPlane& plane) {
const XLine* xla_module_line = FindLineWithName(plane, kXlaModuleLineName);
if (!xla_module_line) return 0ULL;
XPlaneVisitor xplane(&plane);
XLineVisitor xline(&xplane, xla_module_line);
std::set<uint64_t> ordered_module_fps;
xline.ForEachEvent([&](const XEventVisitor& xevent) {
ordered_module_fps.insert(Fingerprint64(xevent.Name()));
});
if (ordered_module_fps.empty()) return 0ULL;
uint64_t output = 0ULL;
for (const auto& fp : ordered_module_fps) {
output = FingerprintCat64(output, fp);
}
return output;
}
std::optional<XEventVisitor> XEventContextTracker::GetContainingEvent(
const Timespan& event) {
if (!line_) return std::nullopt;
if (current_index_ != -1) {
XEventVisitor current_event(plane_, line_, &line_->events(current_index_));
if (current_event.GetTimespan().Includes(event)) {
return current_event;
}
}
for (int i = current_index_ + 1; i < line_->events_size(); ++i) {
XEventVisitor current_event(plane_, line_, &line_->events(i));
if (current_event.TimestampPs() > event.end_ps()) break;
if (current_event.EndTimestampPs() < event.begin_ps()) continue;
current_index_ = i;
if (current_event.GetTimespan().Includes(event)) {
return current_event;
}
break;
}
return std::nullopt;
}
std::optional<XEventVisitor> XEventContextTracker::GetOverlappingEvent(
const Timespan& event) {
if (!line_) return std::nullopt;
if (current_index_ != -1) {
XEventVisitor current_event(plane_, line_, &line_->events(current_index_));
if (current_event.GetTimespan().Overlaps(event)) {
return current_event;
}
}
for (int i = current_index_ + 1; i < line_->events_size(); ++i) {
XEventVisitor current_event(plane_, line_, &line_->events(i));
if (current_event.TimestampPs() > event.end_ps()) break;
if (current_event.EndTimestampPs() < event.begin_ps()) continue;
current_index_ = i;
if (current_event.GetTimespan().Overlaps(event)) {
return current_event;
}
break;
}
return std::nullopt;
}
void AggregateXPlane(const XPlane& full_trace, XPlane& aggregated_trace) {
struct EventStat {
tsl::Stat<int64_t> stat;
int64_t children_duration;
};
using StatByEvent = absl::flat_hash_map<int64_t , EventStat>;
using StatByGroup = absl::flat_hash_map<int64_t , StatByEvent>;
absl::flat_hash_map<int64_t , StatByGroup> stats;
const XPlaneVisitor& plane = CreateTfXPlaneVisitor(&full_trace);
XPlaneBuilder aggregated_plane(&aggregated_trace);
aggregated_plane.SetName(plane.Name());
uint64_t first_op_start_ps = kint64max;
uint64_t last_op_end_ps = 0;
plane.ForEachLine([&](const XLineVisitor& line) {
if (line.Name() == kStepLineName) {
XLineBuilder aggregated_line =
aggregated_plane.GetOrCreateLine(line.Id());
aggregated_line.SetName(kStepLineName);
line.ForEachEvent([&](const XEventVisitor& event) {
CopyEvent(event, plane, full_trace, 0LL, aggregated_plane,
aggregated_line);
});
}
if (!IsOpLineName(line.Name())) return;
XLineBuilder aggregated_line = aggregated_plane.GetOrCreateLine(line.Id());
aggregated_line.SetName(line.Name());
std::vector<XEventVisitor> event_stack;
line.ForEachEvent([&](XEventVisitor event) {
first_op_start_ps = first_op_start_ps <= event.TimestampPs()
? first_op_start_ps
: event.TimestampPs();
last_op_end_ps = last_op_end_ps >= event.EndTimestampPs()
? last_op_end_ps
: event.EndTimestampPs();
const auto& group_stat = event.GetStat(StatType::kGroupId);
int64_t group_id =
group_stat.has_value() ? group_stat->IntOrUintValue() : kint64max;
StatByEvent& line_stats = stats[line.Id()][group_id];
line_stats[event.Id()].stat.UpdateStat(event.DurationPs());
DCHECK(event_stack.empty() || !(event < event_stack.back()));
while (!event_stack.empty() &&
!event_stack.back().GetTimespan().Includes(event.GetTimespan())) {
event_stack.pop_back();
}
if (!event_stack.empty()) {
line_stats[event_stack.back().Id()].children_duration +=
event.DurationPs();
}
event_stack.push_back(std::move(event));
});
});
uint64_t total_time_ps =
(last_op_end_ps && last_op_end_ps > first_op_start_ps)
? last_op_end_ps - first_op_start_ps
: 0;
aggregated_plane.AddStatValue(
*aggregated_plane.GetOrCreateStatMetadata(
GetStatTypeStr(StatType::kTotalProfileDurationPs)),
total_time_ps);
XStatMetadata* kMinDurationPs = aggregated_plane.GetOrCreateStatMetadata(
GetStatTypeStr(StatType::kMinDurationPs));
XStatMetadata* kSelfDurationPs = aggregated_plane.GetOrCreateStatMetadata(
GetStatTypeStr(StatType::kSelfDurationPs));
XStatMetadata* kGroupId = aggregated_plane.GetOrCreateStatMetadata(
GetStatTypeStr(StatType::kGroupId));
for (const auto& [line_id, stats_by_group] : stats) {
XLineBuilder aggregated_line = aggregated_plane.GetOrCreateLine(line_id);
for (const auto& [group_id, stat_by_event] : stats_by_group) {
for (const auto& [event_id, event_stat] : stat_by_event) {
XEventMetadata& event_metadata =
*aggregated_plane.GetOrCreateEventMetadata(event_id);
CopyEventMetadata(*plane.GetEventMetadata(event_id), plane,
event_metadata, aggregated_plane);
XEventBuilder aggregated_event =
aggregated_line.AddEvent(event_metadata);
aggregated_event.SetNumOccurrences(event_stat.stat.count());
aggregated_event.SetDurationPs(event_stat.stat.sum());
if (group_id != kint64max) {
aggregated_event.AddStatValue(*kGroupId, group_id);
}
if (event_stat.stat.count() > 1) {
aggregated_event.AddStatValue(*kMinDurationPs, event_stat.stat.min());
}
if (event_stat.children_duration != 0) {
aggregated_event.AddStatValue( | #include "tsl/profiler/utils/xplane_utils.h"
#include <cstdint>
#include <optional>
#include <string>
#include <utility>
#include <vector>
#include "absl/container/flat_hash_map.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "tsl/platform/test.h"
#include "tsl/platform/types.h"
#include "tsl/profiler/protobuf/xplane.pb.h"
#include "tsl/profiler/utils/math_utils.h"
#include "tsl/profiler/utils/tf_xplane_visitor.h"
#include "tsl/profiler/utils/xplane_builder.h"
#include "tsl/profiler/utils/xplane_schema.h"
#include "tsl/profiler/utils/xplane_visitor.h"
namespace tsl {
namespace profiler {
namespace {
using ::testing::Property;
using ::testing::SizeIs;
using ::testing::UnorderedElementsAre;
#if defined(PLATFORM_GOOGLE)
using ::testing::EqualsProto;
using ::testing::proto::IgnoringRepeatedFieldOrdering;
using ::testing::proto::Partially;
#endif
XEvent CreateEvent(int64_t offset_ps, int64_t duration_ps) {
XEvent event;
event.set_offset_ps(offset_ps);
event.set_duration_ps(duration_ps);
return event;
}
TEST(XPlaneUtilsTest, AddAndRemovePlanes) {
XSpace space;
auto* p1 = FindOrAddMutablePlaneWithName(&space, "p1");
EXPECT_EQ(p1, FindPlaneWithName(space, "p1"));
auto* p2 = FindOrAddMutablePlaneWithName(&space, "p2");
EXPECT_EQ(p2, FindPlaneWithName(space, "p2"));
auto* p3 = FindOrAddMutablePlaneWithName(&space, "p3");
EXPECT_EQ(p3, FindPlaneWithName(space, "p3"));
RemovePlane(&space, p2);
EXPECT_EQ(space.planes_size(), 2);
EXPECT_EQ(p1, FindPlaneWithName(space, "p1"));
EXPECT_EQ(p3, FindPlaneWithName(space, "p3"));
RemovePlane(&space, p1);
EXPECT_EQ(space.planes_size(), 1);
EXPECT_EQ(p3, FindPlaneWithName(space, "p3"));
RemovePlane(&space, p3);
EXPECT_EQ(space.planes_size(), 0);
}
TEST(XPlaneUtilsTest, RemoveEmptyPlanes) {
XSpace space;
RemoveEmptyPlanes(&space);
EXPECT_EQ(space.planes_size(), 0);
auto* plane1 = space.add_planes();
plane1->set_name("p1");
plane1->add_lines()->set_name("p1l1");
plane1->add_lines()->set_name("p1l2");
auto* plane2 = space.add_planes();
plane2->set_name("p2");
auto* plane3 = space.add_planes();
plane3->set_name("p3");
plane3->add_lines()->set_name("p3l1");
auto* plane4 = space.add_planes();
plane4->set_name("p4");
RemoveEmptyPlanes(&space);
ASSERT_EQ(space.planes_size(), 2);
EXPECT_EQ(space.planes(0).name(), "p1");
EXPECT_EQ(space.planes(1).name(), "p3");
}
TEST(XPlaneUtilsTest, RemoveEmptyLines) {
XPlane plane;
RemoveEmptyLines(&plane);
EXPECT_EQ(plane.lines_size(), 0);
auto* line1 = plane.add_lines();
line1->set_name("l1");
line1->add_events();
line1->add_events();
auto* line2 = plane.add_lines();
line2->set_name("l2");
auto* line3 = plane.add_lines();
line3->set_name("l3");
line3->add_events();
auto* line4 = plane.add_lines();
line4->set_name("l4");
RemoveEmptyLines(&plane);
ASSERT_EQ(plane.lines_size(), 2);
EXPECT_EQ(plane.lines(0).name(), "l1");
EXPECT_EQ(plane.lines(1).name(), "l3");
}
TEST(XPlaneUtilsTest, RemoveLine) {
XPlane plane;
const XLine* line1 = plane.add_lines();
const XLine* line2 = plane.add_lines();
const XLine* line3 = plane.add_lines();
RemoveLine(&plane, line2);
ASSERT_EQ(plane.lines_size(), 2);
EXPECT_EQ(&plane.lines(0), line1);
EXPECT_EQ(&plane.lines(1), line3);
}
TEST(XPlaneUtilsTest, RemoveEvents) {
XLine line;
const XEvent* event1 = line.add_events();
const XEvent* event2 = line.add_events();
const XEvent* event3 = line.add_events();
const XEvent* event4 = line.add_events();
RemoveEvents(&line, {event1, event3});
ASSERT_EQ(line.events_size(), 2);
EXPECT_EQ(&line.events(0), event2);
EXPECT_EQ(&line.events(1), event4);
}
TEST(XPlaneUtilsTest, SortXPlaneTest) {
XPlane plane;
XLine* line = plane.add_lines();
*line->add_events() = CreateEvent(200, 100);
*line->add_events() = CreateEvent(100, 100);
*line->add_events() = CreateEvent(120, 50);
*line->add_events() = CreateEvent(120, 30);
SortXPlane(&plane);
ASSERT_EQ(plane.lines_size(), 1);
ASSERT_EQ(plane.lines(0).events_size(), 4);
EXPECT_EQ(plane.lines(0).events(0).offset_ps(), 100);
EXPECT_EQ(plane.lines(0).events(0).duration_ps(), 100);
EXPECT_EQ(plane.lines(0).events(1).offset_ps(), 120);
EXPECT_EQ(plane.lines(0).events(1).duration_ps(), 50);
EXPECT_EQ(plane.lines(0).events(2).offset_ps(), 120);
EXPECT_EQ(plane.lines(0).events(2).duration_ps(), 30);
EXPECT_EQ(plane.lines(0).events(3).offset_ps(), 200);
EXPECT_EQ(plane.lines(0).events(3).duration_ps(), 100);
}
namespace {
XLineBuilder CreateXLine(XPlaneBuilder* plane, absl::string_view name,
absl::string_view display, int64_t id,
int64_t timestamp_ns) {
XLineBuilder line = plane->GetOrCreateLine(id);
line.SetName(name);
line.SetTimestampNs(timestamp_ns);
line.SetDisplayNameIfEmpty(display);
return line;
}
XEventBuilder CreateXEvent(XPlaneBuilder* plane, XLineBuilder line,
absl::string_view event_name,
std::optional<absl::string_view> display,
int64_t offset_ns, int64_t duration_ns) {
XEventMetadata* event_metadata = plane->GetOrCreateEventMetadata(event_name);
if (display) event_metadata->set_display_name(std::string(*display));
XEventBuilder event = line.AddEvent(*event_metadata);
event.SetOffsetNs(offset_ns);
event.SetDurationNs(duration_ns);
return event;
}
template <typename T, typename V>
void CreateXStats(XPlaneBuilder* plane, T* stats_owner,
absl::string_view stats_name, V stats_value) {
stats_owner->AddStatValue(*plane->GetOrCreateStatMetadata(stats_name),
stats_value);
}
void CheckXLine(const XLine& line, absl::string_view name,
absl::string_view display, int64_t start_time_ns,
int64_t events_size) {
EXPECT_EQ(line.name(), name);
EXPECT_EQ(line.display_name(), display);
EXPECT_EQ(line.timestamp_ns(), start_time_ns);
EXPECT_EQ(line.events_size(), events_size);
}
void CheckXEvent(const XEvent& event, const XPlane& plane,
absl::string_view name, absl::string_view display,
int64_t offset_ns, int64_t duration_ns, int64_t stats_size) {
const XEventMetadata& event_metadata =
plane.event_metadata().at(event.metadata_id());
EXPECT_EQ(event_metadata.name(), name);
EXPECT_EQ(event_metadata.display_name(), display);
EXPECT_EQ(event.offset_ps(), NanoToPico(offset_ns));
EXPECT_EQ(event.duration_ps(), NanoToPico(duration_ns));
EXPECT_EQ(event.stats_size(), stats_size);
}
}
TEST(XPlaneUtilsTest, MergeXPlaneTest) {
XPlane src_plane, dst_plane;
constexpr int64_t kLineIdOnlyInSrcPlane = 1LL;
constexpr int64_t kLineIdOnlyInDstPlane = 2LL;
constexpr int64_t kLineIdInBothPlanes = 3LL;
constexpr int64_t kLineIdInBothPlanes2 = 4LL;
{
XPlaneBuilder src(&src_plane);
CreateXStats(&src, &src, "plane_stat1", 1);
CreateXStats(&src, &src, "plane_stat3", 3.0);
auto l1 = CreateXLine(&src, "l1", "d1", kLineIdOnlyInSrcPlane, 100);
auto e1 = CreateXEvent(&src, l1, "event1", "display1", 1, 2);
CreateXStats(&src, &e1, "event_stat1", 2.0);
auto e2 = CreateXEvent(&src, l1, "event2", std::nullopt, 3, 4);
CreateXStats(&src, &e2, "event_stat2", 3);
auto l2 = CreateXLine(&src, "l2", "d2", kLineIdInBothPlanes, 200);
auto e3 = CreateXEvent(&src, l2, "event3", std::nullopt, 5, 7);
CreateXStats(&src, &e3, "event_stat3", 2.0);
auto e4 = CreateXEvent(&src, l2, "event4", std::nullopt, 6, 8);
CreateXStats(&src, &e4, "event_stat4", 3);
CreateXStats(&src, &e4, "event_stat5", 3);
auto l5 = CreateXLine(&src, "l5", "d5", kLineIdInBothPlanes2, 700);
CreateXEvent(&src, l5, "event51", std::nullopt, 9, 10);
CreateXEvent(&src, l5, "event52", std::nullopt, 11, 12);
}
{
XPlaneBuilder dst(&dst_plane);
CreateXStats(&dst, &dst, "plane_stat2", 2);
CreateXStats(&dst, &dst, "plane_stat3", 4);
auto l3 = CreateXLine(&dst, "l3", "d3", kLineIdOnlyInDstPlane, 300);
auto e5 = CreateXEvent(&dst, l3, "event5", std::nullopt, 11, 2);
CreateXStats(&dst, &e5, "event_stat6", 2.0);
auto e6 = CreateXEvent(&dst, l3, "event6", std::nullopt, 13, 4);
CreateXStats(&dst, &e6, "event_stat7", 3);
auto l2 = CreateXLine(&dst, "l4", "d4", kLineIdInBothPlanes, 400);
auto e7 = CreateXEvent(&dst, l2, "event7", std::nullopt, 15, 7);
CreateXStats(&dst, &e7, "event_stat8", 2.0);
auto e8 = CreateXEvent(&dst, l2, "event8", "display8", 16, 8);
CreateXStats(&dst, &e8, "event_stat9", 3);
auto l6 = CreateXLine(&dst, "l6", "d6", kLineIdInBothPlanes2, 300);
CreateXEvent(&dst, l6, "event61", std::nullopt, 21, 10);
CreateXEvent(&dst, l6, "event62", std::nullopt, 22, 12);
}
MergePlanes(src_plane, &dst_plane);
XPlaneVisitor plane(&dst_plane);
EXPECT_EQ(dst_plane.lines_size(), 4);
EXPECT_EQ(dst_plane.stats_size(), 3);
absl::flat_hash_map<absl::string_view, absl::string_view> plane_stats;
plane.ForEachStat([&](const XStatVisitor& stat) {
if (stat.Name() == "plane_stat1") {
EXPECT_EQ(stat.IntValue(), 1);
} else if (stat.Name() == "plane_stat2") {
EXPECT_EQ(stat.IntValue(), 2);
} else if (stat.Name() == "plane_stat3") {
EXPECT_EQ(stat.DoubleValue(), 3.0);
} else {
EXPECT_TRUE(false);
}
});
EXPECT_EQ(dst_plane.stat_metadata_size(), 12);
{
const XLine& line = dst_plane.lines(0);
CheckXLine(line, "l3", "d3", 300, 2);
CheckXEvent(line.events(0), dst_plane, "event5", "", 11, 2, 1);
CheckXEvent(line.events(1), dst_plane, "event6", "", 13, 4, 1);
}
{
const XLine& line = dst_plane.lines(1);
CheckXLine(line, "l4", "d4", 200, 4);
CheckXEvent(line.events(0), dst_plane, "event7", "", 215, 7, 1);
CheckXEvent(line.events(1), dst_plane, "event8", "display8", 216, 8, 1);
CheckXEvent(line.events(2), dst_plane, "event3", "", 5, 7, 1);
CheckXEvent(line.events(3), dst_plane, "event4", "", 6, 8, 2);
}
{
const XLine& line = dst_plane.lines(2);
CheckXLine(line, "l6", "d6", 300, 4);
CheckXEvent(line.events(0), dst_plane, "event61", "", 21, 10, 0);
CheckXEvent(line.events(1), dst_plane, "event62", "", 22, 12, 0);
CheckXEvent(line.events(2), dst_plane, "event51", "", 409, 10, 0);
CheckXEvent(line.events(3), dst_plane, "event52", "", 411, 12, 0);
}
{
const XLine& line = dst_plane.lines(3);
CheckXLine(line, "l1", "d1", 100, 2);
CheckXEvent(line.events(0), dst_plane, "event1", "display1", 1, 2, 1);
CheckXEvent(line.events(1), dst_plane, "event2", "", 3, 4, 1);
}
}
TEST(XPlaneUtilsTest, FindPlanesWithPrefix) {
XSpace xspace;
FindOrAddMutablePlaneWithName(&xspace, "test-prefix:0");
FindOrAddMutablePlaneWithName(&xspace, "test-prefix:1");
FindOrAddMutablePlaneWithName(&xspace, "test-prefix:2");
FindOrAddMutablePlaneWithName(&xspace, "test-prefix:3");
XPlane* p4 = FindOrAddMutablePlaneWithName(&xspace, "test-do-not-include:0");
std::vector<const XPlane*> xplanes =
FindPlanesWithPrefix(xspace, "test-prefix");
ASSERT_EQ(4, xplanes.size());
for (const XPlane* plane : xplanes) {
ASSERT_NE(p4, plane);
}
}
TEST(XplaneUtilsTest, FindMutablePlanesWithPrefix) {
XSpace xspace;
FindOrAddMutablePlaneWithName(&xspace, "test-prefix:0");
FindOrAddMutablePlaneWithName(&xspace, "test-prefix:1");
FindOrAddMutablePlaneWithName(&xspace, "test-prefix:2");
FindOrAddMutablePlaneWithName(&xspace, "test-prefix:3");
XPlane* p4 = FindOrAddMutablePlaneWithName(&xspace, "test-do-not-include:0");
std::vector<XPlane*> xplanes =
FindMutablePlanesWithPrefix(&xspace, "test-prefix");
ASSERT_EQ(4, xplanes.size());
for (XPlane* plane : xplanes) {
ASSERT_NE(p4, plane);
}
}
TEST(XplaneUtilsTest, FindPlanesWithPredicate) {
XSpace xspace;
FindOrAddMutablePlaneWithName(&xspace, "test-prefix:0");
XPlane* p1 = FindOrAddMutablePlaneWithName(&xspace, "test-prefix:1");
std::vector<const XPlane*> xplanes = FindPlanes(
xspace,
[](const XPlane& xplane) { return xplane.name() == "test-prefix:1"; });
ASSERT_EQ(1, xplanes.size());
ASSERT_EQ(p1, xplanes[0]);
}
TEST(XplaneUtilsTest, FindMutablePlanesWithPredicate) {
XSpace xspace;
FindOrAddMutablePlaneWithName(&xspace, "test-prefix:0");
XPlane* p1 = FindOrAddMutablePlaneWithName(&xspace, "test-prefix:1");
std::vector<XPlane*> xplanes = FindMutablePlanes(
&xspace, [](XPlane& xplane) { return xplane.name() == "test-prefix:1"; });
ASSERT_EQ(1, xplanes.size());
ASSERT_EQ(p1, xplanes[0]);
}
TEST(XplaneUtilsTest, TestAggregateXPlanes) {
XPlane xplane;
XPlaneBuilder builder(&xplane);
XEventMetadata* event_metadata1 = builder.GetOrCreateEventMetadata(1);
event_metadata1->set_name("EventMetadata1");
XEventMetadata* event_metadata2 = builder.GetOrCreateEventMetadata(2);
event_metadata2->set_name("EventMetadata2");
XEventMetadata* event_metadata3 = builder.GetOrCreateEventMetadata(3);
event_metadata3->set_name("EventMetadata3");
XEventMetadata* event_metadata4 = builder.GetOrCreateEventMetadata(4);
event_metadata4->set_name("EventMetadata4");
XLineBuilder line = builder.GetOrCreateLine(1);
line.SetName(kTensorFlowOpLineName);
XEventBuilder event1 = line.AddEvent(*event_metadata1);
event1.SetOffsetNs(0);
event1.SetDurationNs(5);
XEventBuilder event3 = line.AddEvent(*event_metadata3);
event3.SetOffsetNs(0);
event3.SetDurationNs(2);
XEventBuilder event2 = line.AddEvent(*event_metadata2);
event2.SetOffsetNs(5);
event2.SetDurationNs(5);
XEventBuilder event4 = line.AddEvent(*event_metadata2);
event4.SetOffsetNs(10);
event4.SetDurationNs(5);
XEventBuilder event5 = line.AddEvent(*event_metadata4);
event5.SetOffsetNs(15);
event5.SetDurationNs(6);
XEventBuilder event6 = line.AddEvent(*event_metadata1);
event6.SetOffsetNs(15);
event6.SetDurationNs(4);
XEventBuilder event7 = line.AddEvent(*event_metadata3);
event7.SetOffsetNs(15);
event7.SetDurationNs(3);
XPlane aggregated_xplane;
AggregateXPlane(xplane, aggregated_xplane);
#if defined(PLATFORM_GOOGLE)
ASSERT_THAT(aggregated_xplane,
IgnoringRepeatedFieldOrdering(EqualsProto(
R"pb(lines {
id: 1
name: "Framework Ops"
events {
metadata_id: 1
duration_ps: 9000
stats { metadata_id: 2 int64_value: 4000 }
stats { metadata_id: 3 int64_value: 4000 }
num_occurrences: 2
}
events {
metadata_id: 3
duration_ps: 5000
stats { metadata_id: 2 int64_value: 2000 }
num_occurrences: 2
}
events {
metadata_id: 4
duration_ps: 6000
stats { metadata_id: 3 int64_value: 2000 }
num_occurrences: 1
}
events {
metadata_id: 2
duration_ps: 10000
stats { metadata_id: 2 int64_value: 5000 }
num_occurrences: 2
}
}
event_metadata {
key: 1
value { id: 1 name: "EventMetadata1" }
}
event_metadata {
key: 2
value { id: 2 name: "EventMetadata2" }
}
event_metadata {
key: 3
value { id: 3 name: "EventMetadata3" }
}
event_metadata {
key: 4
value { id: 4 name: "EventMetadata4" }
}
stat_metadata {
key: 1
value { id: 1 name: "total_profile_duration_ps" }
}
stat_metadata {
key: 2
value { id: 2 name: "min_duration_ps" }
}
stat_metadata {
key: 3
value { id: 3 name: "self_duration_ps" }
}
stat_metadata {
key: 4
value { id: 4 name: "group_id" }
}
stats { metadata_id: 1 uint64_value: 21000 }
)pb")));
#endif
}
TEST(XPlanuUtilsTest, TestInstantEventDoesNotFail) {
XPlane xplane;
XPlaneBuilder xplane_builder(&xplane);
XEventMetadata* event_metadata1 = xplane_builder.GetOrCreateEventMetadata(1);
XEventMetadata* event_metadata2 = xplane_builder.GetOrCreateEventMetadata(2);
XLineBuilder line = xplane_builder.GetOrCreateLine(1);
line.SetName(kTensorFlowOpLineName);
XEventBuilder event1 = line.AddEvent(*event_metadata1);
XEventBuilder event2 = line.AddEvent(*event_metadata2);
event1.SetOffsetNs(1);
event1.SetDurationNs(0);
event2.SetOffsetNs(1);
event2.SetDurationNs(0);
XPlane aggregated_xplane;
AggregateXPlane(xplane, aggregated_xplane);
EXPECT_THAT(aggregated_xplane.lines(),
UnorderedElementsAre(Property(&XLine::events, SizeIs(2))));
}
TEST(XplaneutilsTest, TestEventMetadataStatsAreCopied) {
XPlane xplane;
XPlaneBuilder xplane_builder(&xplane);
XEventMetadata* event_metadata = xplane_builder.GetOrCreateEventMetadata(1);
XStatsBuilder<XEventMetadata> stats(event_metadata, &xplane_builder);
stats.AddStatValue(
*xplane_builder.GetOrCreateStatMetadata(GetStatTypeStr(StatType::kTfOp)),
"TestFunction");
XLineBuilder line = xplane_builder.GetOrCreateLine(1);
line.SetName(kTensorFlowOpLineName);
XEventBuilder event = line.AddEvent(*event_metadata);
event.SetDurationNs(0);
event.SetOffsetNs(0);
XPlane aggregated_xplane;
AggregateXPlane(xplane, aggregated_xplane);
XPlaneVisitor visitor = CreateTfXPlaneVisitor(&aggregated_xplane);
XEventMetadataVisitor metadata_visitor(&visitor, visitor.GetEventMetadata(1));
std::optional<XStatVisitor> stat = metadata_visitor.GetStat(StatType::kTfOp);
ASSERT_TRUE(stat.has_value());
EXPECT_EQ(stat->Name(), "tf_op");
EXPECT_EQ(stat->StrOrRefValue(), "TestFunction");
}
TEST(XplaneutilsTest, TestEventMetadataStatsAreCopiedForRefValue) {
XPlane xplane;
XPlaneBuilder xplane_builder(&xplane);
XEventMetadata* event_metadata = xplane_builder.GetOrCreateEventMetadata(1);
XStatsBuilder<XEventMetadata> stats(event_metadata, &xplane_builder);
stats.AddStatValue(
*xplane_builder.GetOrCreateStatMetadata(GetStatTypeStr(StatType::kTfOp)),
*xplane_builder.GetOrCreateStatMetadata("TestFunction"));
XLineBuilder line = xplane_builder.GetOrCreateLine(1);
line.SetName(kTensorFlowOpLineName);
XEventBuilder event = line.AddEvent(*event_metadata);
event.SetDurationNs(0);
event.SetOffsetNs(0);
XPlane aggregated_xplane;
AggregateXPlane(xplane, aggregated_xplane);
XPlaneVisitor visitor = CreateTfXPlaneVisitor(&aggregated_xplane);
XEventMetadataVisitor metadata_visitor(&visitor, visitor.GetEventMetadata(1));
std::optional<XStatVisitor> stat = metadata_visitor.GetStat(StatType::kTfOp);
ASSERT_TRUE(stat.has_value());
EXPECT_EQ(stat->Name(), "tf_op");
EXPECT_EQ(stat->StrOrRefValue(), "TestFunction");
}
TEST(XplaneutilsTest, TestIsXSpaceGrouped) {
XSpace space;
{
XPlaneBuilder p1(space.add_planes());
auto l1 = CreateXLine(&p1, "l1", "d1", 1, 100);
auto e1 = CreateXEvent(&p1, l1, "event1", "display1", 1, 2);
CreateXStats(&p1, &e1, "event_stat1", 2.0);
}
EXPECT_FALSE(IsXSpaceGrouped(space));
{
XPlaneBuilder p2(space.add_planes());
auto l2 = CreateXLine(&p2, "l2", "d2", 1, 100);
auto e2 = CreateXEvent(&p2, l2, "event2", "display2", 1, 2);
CreateXStats(&p2, &e2, "group_id", 1);
}
LOG(ERROR) << space.DebugString();
EXPECT_TRUE(IsXSpaceGrouped(space));
}
TEST(XplaneutilsTest, TestIsHostPlane) {
XSpace xspace;
auto xplane_host_thread = FindOrAddMutablePlaneWithName(&xspace, "/host:CPU");
auto xplane_host_cpu = FindOrAddMutablePlaneWithName(&xspace, "Host CPUs");
auto xplane_tfstreamz =
FindOrAddMutablePlaneWithName(&xspace, "/host:tfstreamz");
auto xplane_metadata =
FindOrAddMutablePlaneWithName(&xspace, "/host:metadata");
auto xplane_syscalls = FindOrAddMutablePlaneWithName(&xspace, "Syscalls");
auto xplane_python_tracer =
FindOrAddMutablePlaneWithName(&xspace, "/host:python-tracer");
auto xplane_custom_prefix =
FindOrAddMutablePlaneWithName(&xspace, "/device:CUSTOM:123");
auto xplane_legacy_custom =
FindOrAddMutablePlaneWithName(&xspace, "/custom:456");
auto xplane_cupti = FindOrAddMutablePlaneWithName(&xspace, "/host:CUPTI");
EXPECT_TRUE(IsHostPlane(*xplane_host_thread));
EXPECT_TRUE(IsHostPlane(*xplane_host_cpu));
EXPECT_TRUE(IsHostPlane(*xplane_tfstreamz));
EXPECT_TRUE(IsHostPlane(*xplane_metadata));
EXPECT_TRUE(IsHostPlane(*xplane_syscalls));
EXPECT_TRUE(IsHostPlane(*xplane_python_tracer));
EXPECT_FALSE(IsHostPlane(*xplane_custom_prefix));
EXPECT_FALSE(IsHostPlane(*xplane_legacy_custom));
EXPECT_TRUE(IsHostPlane(*xplane_cupti));
}
TEST(XplaneutilsTest, TestIsDevicePlane) {
XSpace xspace;
auto xplane_host_thread = FindOrAddMutablePlaneWithName(&xspace, "/host:CPU");
auto xplane_device_thread =
FindOrAddMutablePlaneWithName(&xspace, "/device:TPU");
auto xplane_task_env_thread =
FindOrAddMutablePlaneWithName(&xspace, "Task Environment");
auto xplane_custom_prefix =
FindOrAddMutablePlaneWithName(&xspace, "/device:CUSTOM:123");
auto xplane_legacy_custom =
FindOrAddMutablePlaneWithName(&xspace, "/custom:456");
EXPECT_FALSE(IsDevicePlane(*xplane_host_thread));
EXPECT_FALSE(IsDevicePlane(*xplane_task_env_thread));
EXPECT_TRUE(IsDevicePlane(*xplane_device_thread));
EXPECT_TRUE(IsDevicePlane(*xplane_custom_prefix));
EXPECT_TRUE(IsDevicePlane(*xplane_legacy_custom));
}
TEST(XplaneUtilsTest, XPlaneGroupingPropagatesStep) {
XPlane xplane;
XPlaneBuilder builder(&xplane);
XStatMetadata* kGroupId =
builder.GetOrCreateStatMetadata(GetStatTypeStr(StatType::kGroupId));
XLineBuilder line = builder.GetOrCreateLine(1);
line.SetName(kStepLineName);
XEventMetadata* event_metadata = builder.GetOrCreateEventMetadata(1);
event_metadata->set_name("Step 1");
XEventBuilder event_builder = line.AddEvent(*event_metadata);
event_builder.AddStatValue(*kGroupId, 1);
event_builder.SetDurationNs(100);
event_builder.SetOffsetNs(100);
XEventMetadata* event_metadata2 = builder.GetOrCreateEventMetadata(2);
event_metadata2->set_name("Step 2");
XEventBuilder event_builder2 = line.AddEvent(*event_metadata2);
event_builder2.AddStatValue(*kGroupId, 2);
event_builder2.SetDurationNs(100);
event_builder2.SetOffsetNs(300);
XPlane aggregated_xplane;
AggregateXPlane(xplane, aggregated_xplane);
#if defined(PLATFORM_GOOGLE)
EXPECT_THAT(aggregated_xplane, Partially(EqualsProto(xplane)));
#endif
}
TEST(XplaneUtilsTest, XPlaneGroupingPropagatesGroupId) {
XPlane xplane;
XPlaneBuilder builder(&xplane);
XEventMetadata* event_metadata1 = builder.GetOrCreateEventMetadata(1);
event_metadata1->set_name("EventMetadata1");
XStatMetadata* kGroupId =
builder.GetOrCreateStatMetadata(GetStatTypeStr(StatType::kGroupId));
XLineBuilder line = builder.GetOrCreateLine(1);
line.SetName(kXlaOpLineName);
XEventBuilder event_builder = line.AddEvent(*event_metadata1);
event_builder.SetDurationNs(100);
event_builder.SetOffsetNs(100);
event_builder.AddStatValue(*kGroupId, 1);
XEventBuilder event_builder2 = line.AddEvent(*event_metadata1);
event_builder2.AddStatValue(*kGroupId, 2);
event_builder2.SetDurationNs(100);
event_builder2.SetOffsetNs(300);
XPlane aggregated_xplane;
AggregateXPlane(xplane, aggregated_xplane);
EXPECT_THAT(aggregated_xplane.lines(),
UnorderedElementsAre(Property(&XLine::events, SizeIs(2))));
XPlaneVisitor visitor = CreateTfXPlaneVisitor(&aggregated_xplane);
visitor.ForEachLine([&](const XLineVisitor& line) {
line.ForEachEvent([&](const XEventVisitor& event) {
EXPECT_TRUE(event.GetStat(StatType::kGroupId).has_value());
});
});
}
}
}
} |
2,625 | cpp | google/tsl | timestamp_utils | tsl/profiler/utils/timestamp_utils.cc | tsl/profiler/utils/timestamp_utils_test.cc | #ifndef TENSORFLOW_TSL_PROFILER_UTILS_TIMESTAMP_UTILS_H_
#define TENSORFLOW_TSL_PROFILER_UTILS_TIMESTAMP_UTILS_H_
#include <cstdint>
#include "tsl/profiler/protobuf/xplane.pb.h"
namespace tsl {
namespace profiler {
void SetSessionTimestamps(uint64_t start_walltime_ns, uint64_t stop_walltime_ns,
tensorflow::profiler::XSpace& space);
}
}
#endif
#include "tsl/profiler/utils/timestamp_utils.h"
#include <cstdint>
#include "absl/log/log.h"
#include "tsl/profiler/protobuf/xplane.pb.h"
#include "tsl/profiler/utils/xplane_builder.h"
#include "tsl/profiler/utils/xplane_schema.h"
#include "tsl/profiler/utils/xplane_utils.h"
namespace tsl {
namespace profiler {
void SetSessionTimestamps(uint64_t start_walltime_ns, uint64_t stop_walltime_ns,
tensorflow::profiler::XSpace& space) {
if (start_walltime_ns != 0 && stop_walltime_ns != 0) {
tsl::profiler::XPlaneBuilder plane(
tsl::profiler::FindOrAddMutablePlaneWithName(
&space, tsl::profiler::kTaskEnvPlaneName));
plane.AddStatValue(*plane.GetOrCreateStatMetadata(
GetTaskEnvStatTypeStr(kEnvProfileStartTime)),
start_walltime_ns);
plane.AddStatValue(*plane.GetOrCreateStatMetadata(
GetTaskEnvStatTypeStr(kEnvProfileStopTime)),
stop_walltime_ns);
} else {
LOG(WARNING) << "Not Setting Session Timestamps, (start_walltime_ns, "
"stop_walltime_ns) : "
<< start_walltime_ns << ", " << stop_walltime_ns;
}
}
}
} | #include "tsl/profiler/utils/timestamp_utils.h"
#include "tsl/platform/test.h"
#include "tsl/profiler/utils/xplane_schema.h"
#include "tsl/profiler/utils/xplane_utils.h"
#include "tsl/profiler/utils/xplane_visitor.h"
namespace tsl {
namespace profiler {
using ::testing::Eq;
TEST(TimestampUtilsTest, StartAndStopTimestampAreAdded) {
XSpace xspace;
SetSessionTimestamps(1000, 2000, xspace);
const XPlane* xplane = FindPlaneWithName(xspace, kTaskEnvPlaneName);
XPlaneVisitor visitor(xplane, {}, {FindTaskEnvStatType});
auto start_time = visitor.GetStat(TaskEnvStatType::kEnvProfileStartTime);
auto stop_time = visitor.GetStat(TaskEnvStatType::kEnvProfileStopTime);
EXPECT_THAT(start_time->IntOrUintValue(), Eq(1000));
EXPECT_THAT(stop_time->IntOrUintValue(), Eq(2000));
}
}
} |
2,626 | cpp | google/tsl | xplane_builder | tsl/profiler/utils/xplane_builder.cc | tsl/profiler/utils/xplane_builder_test.cc | #ifndef TENSORFLOW_TSL_PROFILER_UTILS_XPLANE_BUILDER_H_
#define TENSORFLOW_TSL_PROFILER_UTILS_XPLANE_BUILDER_H_
#include <stddef.h>
#include <cstdint>
#include <string>
#include <utility>
#include <vector>
#include "absl/container/flat_hash_map.h"
#include "absl/meta/type_traits.h"
#include "absl/strings/numbers.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "tsl/platform/macros.h"
#include "tsl/platform/protobuf.h"
#include "tsl/platform/types.h"
#include "tsl/profiler/protobuf/xplane.pb.h"
#include "tsl/profiler/utils/math_utils.h"
#include "tsl/profiler/utils/timespan.h"
namespace tsl {
namespace profiler {
using tensorflow::profiler::XEvent;
using tensorflow::profiler::XEventMetadata;
using tensorflow::profiler::XLine;
using tensorflow::profiler::XPlane;
using tensorflow::profiler::XSpace;
using tensorflow::profiler::XStat;
using tensorflow::profiler::XStatMetadata;
class XPlaneBuilder;
template <typename T>
class XStatsBuilder {
public:
explicit XStatsBuilder(T* stats_owner, XPlaneBuilder* stats_metadata_owner)
: stats_owner_(stats_owner),
stats_metadata_owner_(stats_metadata_owner) {}
template <typename ValueT>
void AddStatValue(const XStatMetadata& metadata, ValueT&& value) {
SetStatValue(std::forward<ValueT>(value), AddStat(metadata));
}
template <typename ValueT>
void SetOrAddStatValue(const XStatMetadata& metadata, ValueT&& value) {
SetStatValue(std::forward<ValueT>(value), FindOrAddStat(metadata));
}
void AddStat(const XStatMetadata& metadata, const XStat& src_stat,
const XPlane& src_plane) {
CopyStatValue(src_stat, src_plane, AddStat(metadata));
}
void SetOrAddStat(const XStatMetadata& metadata, const XStat& src_stat,
const XPlane& src_plane) {
CopyStatValue(src_stat, src_plane, FindOrAddStat(metadata));
}
void ParseAndAddStatValue(const XStatMetadata& metadata,
absl::string_view value) {
int64_t int_value;
uint64 uint_value;
double double_value;
if (absl::SimpleAtoi(value, &int_value)) {
AddStatValue(metadata, int_value);
} else if (absl::SimpleAtoi(value, &uint_value)) {
AddStatValue(metadata, uint_value);
} else if (absl::SimpleAtod(value, &double_value)) {
AddStatValue(metadata, double_value);
} else {
AddStatValue(metadata, GetOrCreateStatMetadata(value));
}
}
void ReserveStats(size_t num_stats) {
stats_owner_->mutable_stats()->Reserve(num_stats);
}
template <typename ForEachStatFunc>
void ForEachStat(ForEachStatFunc&& for_each_stat) {
for (XStat& stat : *stats_owner_->mutable_stats()) {
for_each_stat(&stat);
}
}
const XStat* GetStat(const XStatMetadata& stat_metadata) const {
for (auto& stat : *stats_owner_->mutable_stats()) {
if (stat.metadata_id() == stat_metadata.id()) {
return &stat;
}
}
return nullptr;
}
static uint64 IntOrUintValue(const XStat& stat) {
return stat.value_case() == XStat::kUint64Value ? stat.uint64_value()
: stat.int64_value();
}
absl::string_view StrOrRefValue(const XStat& stat);
private:
XStat* AddStat(const XStatMetadata& metadata) {
XStat* stat = stats_owner_->add_stats();
stat->set_metadata_id(metadata.id());
return stat;
}
XStat* FindOrAddStat(const XStatMetadata& metadata) {
for (auto& stat : *stats_owner_->mutable_stats()) {
if (stat.metadata_id() == metadata.id()) {
return &stat;
}
}
return AddStat(metadata);
}
static void SetStatValue(bool value, XStat* stat) {
stat->set_int64_value(value);
}
template <typename Int,
std::enable_if_t<absl::conjunction<std::is_integral<Int>,
std::is_signed<Int>>::value,
bool> = true>
static void SetStatValue(Int value, XStat* stat) {
stat->set_int64_value(value);
}
template <typename UInt,
std::enable_if_t<
absl::conjunction<std::is_integral<UInt>,
absl::negation<std::is_signed<UInt>>>::value,
bool> = true>
static void SetStatValue(UInt value, XStat* stat) {
stat->set_uint64_value(value);
}
static void SetStatValue(double value, XStat* stat) {
stat->set_double_value(value);
}
static void SetStatValue(const char* value, XStat* stat) {
stat->set_str_value(std::string(value));
}
static void SetStatValue(absl::string_view value, XStat* stat) {
stat->set_str_value(std::string(value));
}
static void SetStatValue(std::string&& value, XStat* stat) {
stat->set_str_value(std::move(value));
}
static void SetStatValue(const XStatMetadata& value, XStat* stat) {
stat->set_ref_value(value.id());
}
static void SetStatValue(const protobuf::MessageLite& proto, XStat* stat) {
auto* bytes = stat->mutable_bytes_value();
proto.SerializeToString(bytes);
}
void CopyStatValue(const XStat& src_stat, const XPlane& src_plane,
XStat* dst_stat) {
switch (src_stat.value_case()) {
case XStat::VALUE_NOT_SET:
break;
case XStat::kInt64Value:
dst_stat->set_int64_value(src_stat.int64_value());
break;
case XStat::kUint64Value:
dst_stat->set_uint64_value(src_stat.uint64_value());
break;
case XStat::kDoubleValue:
dst_stat->set_double_value(src_stat.double_value());
break;
case XStat::kStrValue:
dst_stat->set_str_value(src_stat.str_value());
break;
case XStat::kRefValue: {
const auto& stat_metadata_by_id = src_plane.stat_metadata();
const auto it = stat_metadata_by_id.find(src_stat.ref_value());
if (TF_PREDICT_TRUE(it != stat_metadata_by_id.end())) {
absl::string_view value = it->second.name();
dst_stat->set_ref_value(GetOrCreateStatMetadata(value).id());
}
break;
}
case XStat::kBytesValue:
dst_stat->set_bytes_value(src_stat.bytes_value());
break;
}
}
const XStatMetadata& GetOrCreateStatMetadata(absl::string_view value);
T* stats_owner_;
XPlaneBuilder* stats_metadata_owner_;
};
class XEventBuilder : public XStatsBuilder<XEvent> {
public:
XEventBuilder(const XLine* line, XPlaneBuilder* plane, XEvent* event)
: XStatsBuilder<XEvent>(event, plane), line_(line), event_(event) {}
int64_t LineTimestampPs() const { return NanoToPico(line_->timestamp_ns()); }
int64_t OffsetPs() const { return event_->offset_ps(); }
int64_t TimestampPs() const { return LineTimestampPs() + OffsetPs(); }
int64_t DurationPs() const { return event_->duration_ps(); }
int64_t MetadataId() const { return event_->metadata_id(); }
void SetOffsetPs(int64_t offset_ps) { event_->set_offset_ps(offset_ps); }
void SetOffsetNs(int64_t offset_ns) { SetOffsetPs(NanoToPico(offset_ns)); }
void SetTimestampPs(int64_t timestamp_ps) {
SetOffsetPs(timestamp_ps - LineTimestampPs());
}
void SetTimestampNs(int64_t timestamp_ns) {
SetOffsetNs(timestamp_ns - line_->timestamp_ns());
}
void SetNumOccurrences(int64_t num_occurrences) {
event_->set_num_occurrences(num_occurrences);
}
void SetDurationPs(int64_t duration_ps) {
event_->set_duration_ps(duration_ps);
}
void SetDurationNs(int64_t duration_ns) {
SetDurationPs(NanoToPico(duration_ns));
}
void SetEndTimestampPs(int64_t end_timestamp_ps) {
SetDurationPs(end_timestamp_ps - TimestampPs());
}
void SetEndTimestampNs(int64_t end_timestamp_ns) {
SetDurationPs(NanoToPico(end_timestamp_ns - line_->timestamp_ns()) -
event_->offset_ps());
}
Timespan GetTimespan() const { return Timespan(TimestampPs(), DurationPs()); }
void SetTimespan(Timespan timespan) {
SetTimestampPs(timespan.begin_ps());
SetDurationPs(timespan.duration_ps());
}
bool operator<(const XEventBuilder& other) const {
return GetTimespan() < other.GetTimespan();
}
private:
const XLine* line_;
XEvent* event_;
};
class XLineBuilder {
public:
explicit XLineBuilder(XLine* line, XPlaneBuilder* plane)
: line_(line), plane_(plane) {}
XPlaneBuilder* Plane() const { return plane_; }
int64_t Id() const { return line_->id(); }
void SetId(int64_t id) { line_->set_id(id); }
int64_t NumEvents() const { return line_->events_size(); }
absl::string_view Name() const { return line_->name(); }
void SetName(absl::string_view name) { line_->set_name(std::string(name)); }
void SetNameIfEmpty(absl::string_view name) {
if (line_->name().empty()) SetName(name);
}
int64_t TimestampNs() const { return line_->timestamp_ns(); }
void SetTimestampNs(int64_t timestamp_ns) {
line_->set_timestamp_ns(timestamp_ns);
}
void SetTimestampNsAndAdjustEventOffsets(int64_t timestamp_ns);
void SetDurationPs(int64_t duration_ps) {
line_->set_duration_ps(duration_ps);
}
void ReserveEvents(size_t num_events) {
line_->mutable_events()->Reserve(num_events);
}
void SetDisplayNameIfEmpty(absl::string_view display_name) {
if (line_->display_name().empty()) {
line_->set_display_name(std::string(display_name));
}
}
XEventBuilder AddEvent(const XEventMetadata& metadata);
XEventBuilder AddEvent(const XEvent& event);
template <typename ForEachEventFunc>
void ForEachEvent(ForEachEventFunc&& for_each_event) {
for (XEvent& event : *line_->mutable_events()) {
for_each_event(XEventBuilder(line_, plane_, &event));
}
}
private:
XLine* line_;
XPlaneBuilder* plane_;
};
class XPlaneBuilder : public XStatsBuilder<XPlane> {
public:
explicit XPlaneBuilder(XPlane* plane);
int64_t Id() const { return plane_->id(); }
void SetId(int64_t id) { plane_->set_id(id); }
absl::string_view Name() const { return plane_->name(); }
void SetName(absl::string_view name) { plane_->set_name(std::string(name)); }
void ReserveLines(size_t num_lines) {
plane_->mutable_lines()->Reserve(num_lines);
}
template <typename ForEachLineFunc>
void ForEachLine(ForEachLineFunc&& for_each_line) {
for (XLine& line : *plane_->mutable_lines()) {
for_each_line(XLineBuilder(&line, this));
}
}
XLineBuilder GetOrCreateLine(int64_t line_id);
XEventMetadata* CreateEventMetadata();
XEventMetadata* GetOrCreateEventMetadata(int64_t metadata_id);
XEventMetadata* GetOrCreateEventMetadata(absl::string_view name);
XEventMetadata* GetOrCreateEventMetadata(std::string&& name);
XEventMetadata* GetOrCreateEventMetadata(const char* name) {
return GetOrCreateEventMetadata(absl::string_view(name));
}
std::vector<XEventMetadata*> GetOrCreateEventsMetadata(
const std::vector<absl::string_view>& names);
XEventMetadata* GetEventMetadata(absl::string_view name) const;
XStatMetadata* GetStatMetadata(absl::string_view name) const;
const XStatMetadata* GetStatMetadata(int64_t metadata_id) const;
XStatMetadata* CreateStatMetadata();
XStatMetadata* GetOrCreateStatMetadata(int64_t metadata_id);
XStatMetadata* GetOrCreateStatMetadata(absl::string_view name);
XStatMetadata* GetOrCreateStatMetadata(std::string&& name);
XStatMetadata* GetOrCreateStatMetadata(const char* name) {
return GetOrCreateStatMetadata(absl::string_view(name));
}
private:
XPlane* plane_;
int64_t last_event_metadata_id_ = 0LL;
int64_t last_stat_metadata_id_ = 0LL;
absl::flat_hash_map<std::string, XEventMetadata*> event_metadata_by_name_;
absl::flat_hash_map<std::string, XStatMetadata*> stat_metadata_by_name_;
absl::flat_hash_map<int64_t, XLine*> lines_by_id_;
};
template <typename T>
const XStatMetadata& XStatsBuilder<T>::GetOrCreateStatMetadata(
absl::string_view value) {
return *stats_metadata_owner_->GetOrCreateStatMetadata(value);
}
template <typename T>
absl::string_view XStatsBuilder<T>::StrOrRefValue(const XStat& stat) {
switch (stat.value_case()) {
case XStat::kStrValue:
return stat.str_value();
case XStat::kRefValue: {
auto* ref_stat = stats_metadata_owner_->GetStatMetadata(stat.ref_value());
return ref_stat ? ref_stat->name() : absl::string_view();
}
case XStat::kInt64Value:
case XStat::kUint64Value:
case XStat::kDoubleValue:
case XStat::kBytesValue:
case XStat::VALUE_NOT_SET:
return absl::string_view();
}
}
}
}
#endif
#include "tsl/profiler/utils/xplane_builder.h"
#include <algorithm>
#include <string>
#include <utility>
#include <vector>
#include "absl/container/flat_hash_map.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "tsl/platform/types.h"
#include "tsl/profiler/protobuf/xplane.pb.h"
#include "tsl/profiler/utils/math_utils.h"
namespace tsl {
namespace profiler {
XPlaneBuilder::XPlaneBuilder(XPlane* plane)
: XStatsBuilder<XPlane>(plane, this), plane_(plane) {
for (auto& id_and_metadata : *plane->mutable_event_metadata()) {
auto& metadata = id_and_metadata.second;
last_event_metadata_id_ =
std::max<int64_t>(last_event_metadata_id_, metadata.id());
if (!metadata.name().empty()) {
event_metadata_by_name_.try_emplace(metadata.name(), &metadata);
}
}
for (auto& id_and_metadata : *plane->mutable_stat_metadata()) {
auto& metadata = id_and_metadata.second;
last_stat_metadata_id_ =
std::max<int64_t>(last_stat_metadata_id_, metadata.id());
if (!metadata.name().empty()) {
stat_metadata_by_name_.try_emplace(metadata.name(), &metadata);
}
}
for (XLine& line : *plane->mutable_lines()) {
lines_by_id_.try_emplace(line.id(), &line);
}
}
XEventMetadata* XPlaneBuilder::GetOrCreateEventMetadata(int64_t metadata_id) {
XEventMetadata& metadata = (*plane_->mutable_event_metadata())[metadata_id];
metadata.set_id(metadata_id);
return &metadata;
}
XEventMetadata* XPlaneBuilder::CreateEventMetadata() {
return GetOrCreateEventMetadata(++last_event_metadata_id_);
}
XEventMetadata* XPlaneBuilder::GetOrCreateEventMetadata(
absl::string_view name) {
XEventMetadata*& metadata = event_metadata_by_name_[name];
if (metadata == nullptr) {
metadata = CreateEventMetadata();
metadata->set_name(std::string(name));
}
return metadata;
}
XEventMetadata* XPlaneBuilder::GetOrCreateEventMetadata(std::string&& name) {
XEventMetadata*& metadata = event_metadata_by_name_[name];
if (metadata == nullptr) {
metadata = CreateEventMetadata();
metadata->set_name(std::move(name));
}
return metadata;
}
std::vector<XEventMetadata*> XPlaneBuilder::GetOrCreateEventsMetadata(
const std::vector<absl::string_view>& names) {
std::vector<XEventMetadata*> metadata;
metadata.reserve(names.size());
for (absl::string_view name : names) {
metadata.push_back(GetOrCreateEventMetadata(name));
}
return metadata;
}
XEventMetadata* XPlaneBuilder::GetEventMetadata(absl::string_view name) const {
auto result = event_metadata_by_name_.find(name);
if (result == event_metadata_by_name_.end()) return nullptr;
return result->second;
}
XStatMetadata* XPlaneBuilder::GetStatMetadata(absl::string_view name) const {
auto result = stat_metadata_by_name_.find(name);
if (result == stat_metadata_by_name_.end()) return nullptr;
return result->second;
}
XStatMetadata* XPlaneBuilder::GetOrCreateStatMetadata(int64_t metadata_id) {
XStatMetadata& metadata = (*plane_->mutable_stat_metadata())[metadata_id];
metadata.set_id(metadata_id);
return &metadata;
}
const XStatMetadata* XPlaneBuilder::GetStatMetadata(int64_t metadata_id) const {
auto result = plane_->stat_metadata().find(metadata_id);
if (result == plane_->stat_metadata().end()) return nullptr;
return &(result->second);
}
XStatMetadata* XPlaneBuilder::CreateStatMetadata() {
return GetOrCreateStatMetadata(++last_stat_metadata_id_);
}
XStatMetadata* XPlaneBuilder::GetOrCreateStatMetadata(absl::string_view name) {
XStatMetadata*& metadata = stat_metadata_by_name_[name];
if (metadata == nullptr) {
metadata = CreateStatMetadata();
metadata->set_name(std::string(name));
}
return metadata;
}
XStatMetadata* XPlaneBuilder::GetOrCreateStatMetadata(std::string&& name) {
XStatMetadata*& metadata = stat_metadata_by_name_[name];
if (metadata == nullptr) {
metadata = CreateStatMetadata();
metadata->set_name(std::move(name));
}
return metadata;
}
XLineBuilder XPlaneBuilder::GetOrCreateLine(int64_t line_id) {
XLine*& line = lines_by_id_[line_id];
if (line == nullptr) {
line = plane_->add_lines();
line->set_id(line_id);
}
return XLineBuilder(line, this);
}
XEventBuilder XLineBuilder::AddEvent(const XEventMetadata& metadata) {
XEvent* event = line_->add_events();
event->set_metadata_id(metadata.id());
return XEventBuilder(line_, plane_, event);
}
XEventBuilder XLineBuilder::AddEvent(const XEvent& event) {
XEvent* new_event = line_->add_events();
*new_event = event;
return XEventBuilder(line_, plane_, new_event);
}
void XLineBuilder::SetTimestampNsAndAdjustEventOffsets(int64_t timestamp_ns) {
int64_t offset_ps = NanoToPico(line_->timestamp_ns() - timestamp_ns);
line_->set_timestamp_ns(timestamp_ns);
if (offset_ps) {
for (auto& event : *line_->mutable_events()) {
event.set_offset_ps(event.offset_ps() + offset_ps);
}
}
}
}
} | #include "tsl/profiler/utils/xplane_builder.h"
#include <string>
#include "absl/strings/string_view.h"
#include "tsl/platform/test.h"
#include "tsl/profiler/protobuf/xplane.pb.h"
#include "tsl/profiler/utils/xplane_visitor.h"
namespace tsl {
namespace profiler {
namespace {
TEST(TimespanTests, NonInstantSpanIncludesSingleTimeTests) {
XPlane plane;
XPlaneBuilder xplane_builder(&plane);
XLineBuilder xline_builder = xplane_builder.GetOrCreateLine(0);
XEventBuilder event_builder = xline_builder.AddEvent(
*xplane_builder.GetOrCreateEventMetadata("1st event"));
constexpr auto kBoolStat = true;
constexpr auto kInt32Stat = int32_t{1234};
constexpr auto kInt64Stat = int64_t{1234} << 32;
constexpr auto kUint32Stat = uint32_t{5678};
constexpr auto kUint64Stat = uint64_t{5678} << 32;
constexpr auto kFloatStat = 0.5f;
constexpr auto kDoubleStat = 1.0;
constexpr auto kStringStat = "abc";
constexpr auto kRefStat = "referenced abc";
event_builder.AddStatValue(
*xplane_builder.GetOrCreateStatMetadata("bool stat"), kBoolStat);
event_builder.AddStatValue(
*xplane_builder.GetOrCreateStatMetadata("int32 stat"), kInt32Stat);
event_builder.AddStatValue(
*xplane_builder.GetOrCreateStatMetadata("int64 stat"), kInt64Stat);
event_builder.AddStatValue(
*xplane_builder.GetOrCreateStatMetadata("uint32 stat"), kUint32Stat);
event_builder.AddStatValue(
*xplane_builder.GetOrCreateStatMetadata("uint64 stat"), kUint64Stat);
event_builder.AddStatValue(
*xplane_builder.GetOrCreateStatMetadata("string stat"), kStringStat);
event_builder.AddStatValue(
*xplane_builder.GetOrCreateStatMetadata("float stat"), kFloatStat);
event_builder.AddStatValue(
*xplane_builder.GetOrCreateStatMetadata("double stat"), kDoubleStat);
event_builder.AddStatValue(
*xplane_builder.GetOrCreateStatMetadata("ref stat"),
*xplane_builder.GetOrCreateStatMetadata(kRefStat));
XPlaneVisitor xplane_visitor(&plane);
EXPECT_EQ(xplane_visitor.NumLines(), 1);
int num_stats = 0;
xplane_visitor.ForEachLine([&](const XLineVisitor& xline) {
xline.ForEachEvent([&](const XEventVisitor& xevent) {
EXPECT_EQ(xevent.Name(), "1st event");
xevent.ForEachStat([&](const XStatVisitor& stat) {
if (stat.Name() == "bool stat") {
EXPECT_EQ(stat.BoolValue(), kBoolStat);
num_stats++;
} else if (stat.Name() == "int32 stat") {
EXPECT_EQ(stat.IntValue(), kInt32Stat);
EXPECT_EQ(stat.IntOrUintValue(), kInt32Stat);
num_stats++;
} else if (stat.Name() == "int64 stat") {
EXPECT_EQ(stat.IntValue(), kInt64Stat);
EXPECT_EQ(stat.IntOrUintValue(), kInt64Stat);
num_stats++;
} else if (stat.Name() == "uint32 stat") {
EXPECT_EQ(stat.UintValue(), kUint32Stat);
EXPECT_EQ(stat.IntOrUintValue(), kUint32Stat);
num_stats++;
} else if (stat.Name() == "uint64 stat") {
EXPECT_EQ(stat.UintValue(), kUint64Stat);
EXPECT_EQ(stat.IntOrUintValue(), kUint64Stat);
num_stats++;
} else if (stat.Name() == "string stat") {
EXPECT_EQ(stat.StrOrRefValue(), kStringStat);
num_stats++;
} else if (stat.Name() == "float stat") {
EXPECT_EQ(stat.DoubleValue(), kFloatStat);
num_stats++;
} else if (stat.Name() == "double stat") {
EXPECT_EQ(stat.DoubleValue(), kDoubleStat);
num_stats++;
} else if (stat.Name() == "ref stat") {
EXPECT_EQ(stat.StrOrRefValue(), kRefStat);
num_stats++;
}
});
});
});
EXPECT_EQ(num_stats, 9);
}
}
}
} |
2,627 | cpp | google/tsl | preprocess_xplane | tsl/profiler/utils/preprocess_xplane.cc | tsl/profiler/utils/preprocess_xplane_test.cc | #ifndef TENSORFLOW_TSL_PROFILER_UTILS_PREPROCESS_XPLANE_H_
#define TENSORFLOW_TSL_PROFILER_UTILS_PREPROCESS_XPLANE_H_
#include <cstdint>
#include <memory>
#include <optional>
#include <tuple>
#include <type_traits>
#include <utility>
#include <variant>
#include <vector>
#include "absl/hash/hash.h"
#include "absl/log/log.h"
#include "absl/memory/memory.h"
#include "absl/strings/match.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "tsl/profiler/lib/context_types.h"
#include "tsl/profiler/protobuf/xplane.pb.h"
#include "tsl/profiler/utils/tpu_xplane_utils.h"
#include "tsl/profiler/utils/trace_utils.h"
#include "tsl/profiler/utils/xplane_builder.h"
#include "tsl/profiler/utils/xplane_mutators.h"
#include "tsl/profiler/utils/xplane_schema.h"
namespace tsl {
namespace profiler {
static constexpr uint32_t kRunIdMask = (1U << 27) - 1;
class XplaneRootEventMutatorFactory : public XplaneEventMutatorFactory {
public:
static std::unique_ptr<XplaneEventMutatorFactory> CreateFactory(
HostEventType event_type, int64_t root_level) {
return absl::WrapUnique(
new XplaneRootEventMutatorFactory(event_type, root_level));
}
std::vector<std::unique_ptr<XplaneEventMutator>> CreateMutators(
XPlaneBuilder& xplane) const override {
std::vector<std::unique_ptr<XplaneEventMutator>> mutators;
if (auto* event_metadata =
xplane.GetEventMetadata(GetHostEventTypeStr(event_type_))) {
XStatMetadata* root_metadata =
xplane.GetOrCreateStatMetadata(GetStatTypeStr(StatType::kIsRoot));
mutators.emplace_back(std::make_unique<XplaneRootEventMutator>(
event_metadata, *root_metadata, root_level_));
}
return mutators;
}
private:
explicit XplaneRootEventMutatorFactory(HostEventType event_type,
int64_t root_level)
: event_type_(event_type), root_level_(root_level) {}
class XplaneRootEventMutator : public XplaneEventMutator {
public:
XplaneRootEventMutator(XEventMetadata* event_metadata,
XStatMetadata& root_stats_metadata,
int64_t root_level)
: XplaneEventMutator(event_metadata),
root_stats_metadata_(root_stats_metadata),
root_level_(root_level) {}
void Mutate(XEventBuilder& event_builder) override {
event_builder.SetOrAddStatValue(root_stats_metadata_, root_level_);
}
void MutateEventsInLine(XLineBuilder& line) override {
CHECK(false);
}
private:
XStatMetadata& root_stats_metadata_;
int64_t root_level_;
};
HostEventType event_type_;
int64_t root_level_;
};
template <typename StatValueType, StatType kStatId>
class XContextStatsAccessor {
public:
using value_type = StatValueType;
bool Initialize(XPlaneBuilder& xplane) {
stats_metadata_ = xplane.GetStatMetadata(GetStatTypeStr(kStatId));
return stats_metadata_;
}
std::optional<StatValueType> GetStat(XEventBuilder& event_builder) {
if (stats_metadata_ == nullptr) return std::nullopt;
auto* stat = event_builder.GetStat(*stats_metadata_);
if (stat == nullptr) return std::nullopt;
if constexpr (std::is_integral_v<StatValueType>) {
return event_builder.IntOrUintValue(*stat);
} else {
return event_builder.StrOrRefValue(*stat);
}
}
private:
XStatMetadata* stats_metadata_ = nullptr;
};
template <typename StatValueType, StatType kStatId, StatValueType kDefaultValue>
class XContextStatsAccessorWithDefault {
public:
using value_type = StatValueType;
bool Initialize(XPlaneBuilder& xplane) {
stats_metadata_ = xplane.GetStatMetadata(GetStatTypeStr(kStatId));
return true;
}
std::optional<StatValueType> GetStat(XEventBuilder& event_builder) {
if (stats_metadata_ == nullptr) return kDefaultValue;
auto* stat = event_builder.GetStat(*stats_metadata_);
if (stat == nullptr) return kDefaultValue;
if constexpr (std::is_integral_v<StatValueType>) {
return event_builder.IntOrUintValue(*stat);
} else {
return event_builder.StrOrRefValue(*stat);
}
}
private:
XStatMetadata* stats_metadata_ = nullptr;
};
template <std::size_t... Idx>
auto make_index_dispatcher(std::index_sequence<Idx...>) {
return [](auto&& f) { (f(std::integral_constant<std::size_t, Idx>{}), ...); };
}
template <std::size_t N>
auto make_index_dispatcher() {
return make_index_dispatcher(std::make_index_sequence<N>{});
}
template <typename Tuple, typename Func>
void for_each(Tuple&& t, Func&& f) {
constexpr auto n = std::tuple_size<std::decay_t<Tuple>>::value;
auto dispatcher = make_index_dispatcher<n>();
dispatcher([&f, &t](auto idx) { f(std::get<idx>(std::forward<Tuple>(t))); });
}
template <HostEventType producer_event, HostEventType consumer_event,
ContextType context_type, bool unique_stats,
typename... StatsAccessorTypes>
class XplaneConnectedEventMutatorFactory : public XplaneEventMutatorFactory {
public:
static std::unique_ptr<XplaneEventMutatorFactory> CreateFactory() {
return absl::WrapUnique(new XplaneConnectedEventMutatorFactory());
}
using StatsAccessors = std::tuple<StatsAccessorTypes...>;
std::vector<std::unique_ptr<XplaneEventMutator>> CreateMutators(
XPlaneBuilder& xplane) const override {
StatsAccessors stats_accessors;
bool all_required_stats_exist = true;
auto check_stats_meta = [&all_required_stats_exist,
&xplane](auto&& accessor) {
all_required_stats_exist =
all_required_stats_exist && accessor.Initialize(xplane);
};
for_each(stats_accessors, check_stats_meta);
if (!all_required_stats_exist) return {};
XEventMetadata* producer_event_metadata =
xplane.GetEventMetadata(GetHostEventTypeStr(producer_event));
XEventMetadata* consumer_event_metadata =
xplane.GetEventMetadata(GetHostEventTypeStr(consumer_event));
std::vector<std::unique_ptr<XplaneEventMutator>> mutators;
if (producer_event_metadata) {
XStatMetadata* context_type_metadata = xplane.GetOrCreateStatMetadata(
GetStatTypeStr(StatType::kProducerType));
XStatMetadata* context_id_metadata =
xplane.GetOrCreateStatMetadata(GetStatTypeStr(StatType::kProducerId));
mutators.emplace_back(std::make_unique<XplaneConnectedEventMutator>(
producer_event_metadata, *context_type_metadata, *context_id_metadata,
stats_accessors));
}
if (consumer_event_metadata) {
XStatMetadata* context_type_metadata = xplane.GetOrCreateStatMetadata(
GetStatTypeStr(StatType::kConsumerType));
XStatMetadata* context_id_metadata =
xplane.GetOrCreateStatMetadata(GetStatTypeStr(StatType::kConsumerId));
mutators.emplace_back(std::make_unique<XplaneConnectedEventMutator>(
consumer_event_metadata, *context_type_metadata, *context_id_metadata,
stats_accessors));
}
return mutators;
}
private:
XplaneConnectedEventMutatorFactory() = default;
class XplaneConnectedEventMutator : public XplaneEventMutator {
public:
XplaneConnectedEventMutator(XEventMetadata* event_metadata,
XStatMetadata& context_type_metadata,
XStatMetadata& context_id_metadata,
const StatsAccessors& accessors)
: XplaneEventMutator(event_metadata),
context_type_metadata_(context_type_metadata),
context_id_metadata_(context_id_metadata),
accessors_(accessors) {}
void Mutate(XEventBuilder& event_builder) override {
bool all_required_stats_exist = true;
std::vector<std::variant<absl::string_view, uint64_t>> required_stats;
auto check_stats_meta = [&all_required_stats_exist, &required_stats,
&event_builder](auto&& accessor) {
if (all_required_stats_exist == false) return;
auto stats_data = accessor.GetStat(event_builder);
if (!stats_data) {
all_required_stats_exist = false;
} else {
required_stats.emplace_back(*stats_data);
}
};
for_each(accessors_, check_stats_meta);
if (!all_required_stats_exist) return;
int64_t context_id;
if constexpr (unique_stats) {
context_id = absl::HashOf(required_stats);
} else {
context_id =
absl::HashOf(producer_event, consumer_event, required_stats);
}
event_builder.SetOrAddStatValue(context_type_metadata_,
static_cast<int64_t>(context_type));
event_builder.SetOrAddStatValue(context_id_metadata_, context_id);
}
void MutateEventsInLine(XLineBuilder& line) override {
CHECK(false);
}
private:
XStatMetadata& context_type_metadata_;
XStatMetadata& context_id_metadata_;
StatsAccessors accessors_;
};
};
template <HostEventType event_type>
class HostRunIdMutatorFactory : public XplaneEventMutatorFactory {
public:
static std::unique_ptr<XplaneEventMutatorFactory> CreateFactory() {
return absl::WrapUnique(new HostRunIdMutatorFactory());
}
std::vector<std::unique_ptr<XplaneEventMutator>> CreateMutators(
XPlaneBuilder& xplane) const override {
std::vector<std::unique_ptr<XplaneEventMutator>> mutators;
if (auto* event_metadata =
xplane.GetEventMetadata(GetHostEventTypeStr(event_type))) {
XContextStatsAccessor<int64_t, StatType::kRunId> run_id_stats_accessor;
if (run_id_stats_accessor.Initialize(xplane)) {
XStatMetadata* run_id_metadata =
xplane.GetOrCreateStatMetadata(GetStatTypeStr(StatType::kRunId));
mutators.emplace_back(std::make_unique<HostRunIdMutator>(
event_metadata, run_id_stats_accessor, *run_id_metadata));
}
}
return mutators;
}
private:
HostRunIdMutatorFactory() = default;
class HostRunIdMutator : public XplaneEventMutator {
public:
HostRunIdMutator(
XEventMetadata* event_metadata,
XContextStatsAccessor<int64_t, StatType::kRunId> run_id_stats_accessor,
XStatMetadata& run_id_metadata)
: XplaneEventMutator(event_metadata),
run_id_stats_accessor_(run_id_stats_accessor),
run_id_metadata_(run_id_metadata) {}
void Mutate(XEventBuilder& event_builder) override {
auto run_id = run_id_stats_accessor_.GetStat(event_builder);
if (!run_id) return;
int64_t fixed_run_id = ((uint64_t)run_id.value() & kRunIdMask);
event_builder.SetOrAddStatValue(run_id_metadata_, fixed_run_id);
}
void MutateEventsInLine(XLineBuilder& line) override {
CHECK(false);
}
private:
XContextStatsAccessor<int64_t, StatType::kRunId> run_id_stats_accessor_;
XStatMetadata& run_id_metadata_;
};
};
class TpuModuleLineMutatorFactory : public XplaneEventMutatorFactory {
public:
static std::unique_ptr<XplaneEventMutatorFactory> CreateFactory() {
return absl::WrapUnique(new TpuModuleLineMutatorFactory());
}
std::vector<std::unique_ptr<XplaneEventMutator>> CreateMutators(
XPlaneBuilder& xplane) const override {
std::vector<std::unique_ptr<XplaneEventMutator>> mutators;
if (absl::StartsWith(xplane.Name(), kTpuPlanePrefix) &&
GetTensorCoreId(xplane.Name()).has_value()) {
if (auto device_ordinal = ParseDeviceOrdinal(xplane.Name())) {
XStatMetadata* context_type_metadata = xplane.GetOrCreateStatMetadata(
GetStatTypeStr(StatType::kConsumerType));
XStatMetadata* context_id_metadata = xplane.GetOrCreateStatMetadata(
GetStatTypeStr(StatType::kConsumerId));
XContextStatsAccessor<uint64_t, StatType::kQueueId>
queue_id_stats_accessor;
XContextStatsAccessor<uint64_t, StatType::kRunId> run_id_stats_accessor;
XContextStatsAccessorWithDefault<uint64_t, StatType::kCoreType, 0ULL>
core_type_stats_accessor;
if (queue_id_stats_accessor.Initialize(xplane) &&
run_id_stats_accessor.Initialize(xplane) &&
core_type_stats_accessor.Initialize(xplane)) {
mutators.emplace_back(std::make_unique<TpuModuleLineMutator>(
*device_ordinal, *context_type_metadata, *context_id_metadata,
queue_id_stats_accessor, run_id_stats_accessor,
core_type_stats_accessor));
}
}
}
return mutators;
}
private:
TpuModuleLineMutatorFactory() = default;
class TpuModuleLineMutator : public XplaneEventMutator {
public:
TpuModuleLineMutator(
uint32_t device_ordinal, XStatMetadata& context_type_metadata,
XStatMetadata& context_id_metadata,
XContextStatsAccessor<uint64_t, StatType::kQueueId>
queue_id_stats_accessor,
XContextStatsAccessor<uint64_t, StatType::kRunId> run_id_stats_accessor,
XContextStatsAccessorWithDefault<uint64_t, StatType::kCoreType, 0ULL>
core_type_stats_accessor)
: XplaneEventMutator(nullptr),
device_ordinal_(device_ordinal),
context_type_metadata_(context_type_metadata),
context_id_metadata_(context_id_metadata),
queue_id_stats_accessor_(queue_id_stats_accessor),
run_id_stats_accessor_(run_id_stats_accessor),
core_type_stats_accessor_(core_type_stats_accessor) {}
void Mutate(XEventBuilder& event_builder) override {
CHECK(false);
}
void MutateEventsInLine(XLineBuilder& line) override {
if (line.Name() != kXlaModuleLineName) return;
line.ForEachEvent([&](XEventBuilder event) {
auto run_id = run_id_stats_accessor_.GetStat(event);
auto queue_id = queue_id_stats_accessor_.GetStat(event);
auto core_type = core_type_stats_accessor_.GetStat(event);
if (!run_id || !queue_id) return;
std::vector<std::variant<absl::string_view, uint64_t>> required_stats;
required_stats.reserve(4);
required_stats.emplace_back(device_ordinal_);
required_stats.emplace_back(*queue_id);
required_stats.emplace_back(*run_id);
required_stats.emplace_back(static_cast<uint64_t>(*core_type));
int64_t context_id = absl::HashOf(required_stats);
event.SetOrAddStatValue(context_type_metadata_,
static_cast<int64_t>(ContextType::kTpuLaunch));
event.SetOrAddStatValue(context_id_metadata_, context_id);
});
}
private:
uint64_t device_ordinal_;
XStatMetadata& context_type_metadata_;
XStatMetadata& context_id_metadata_;
XContextStatsAccessor<uint64_t, StatType::kQueueId>
queue_id_stats_accessor_;
XContextStatsAccessor<uint64_t, StatType::kRunId> run_id_stats_accessor_;
XContextStatsAccessorWithDefault<uint64_t, StatType::kCoreType, 0ULL>
core_type_stats_accessor_;
};
};
class ThreadpoolLineMutatorFactory : public XplaneEventMutatorFactory {
public:
static std::unique_ptr<XplaneEventMutatorFactory> CreateFactory() {
return absl::WrapUnique(new ThreadpoolLineMutatorFactory());
}
std::vector<std::unique_ptr<XplaneEventMutator>> CreateMutators(
XPlaneBuilder& xplane) const override {
std::vector<std::unique_ptr<XplaneEventMutator>> mutators;
mutators.emplace_back(std::make_unique<ThreadpoolLineMutator>(xplane));
return mutators;
}
private:
ThreadpoolLineMutatorFactory() = default;
class ThreadpoolLineMutator : public XplaneEventMutator {
public:
explicit ThreadpoolLineMutator(XPlaneBuilder& xplane)
: XplaneEventMutator(nullptr), xplane_(xplane) {
start_region_metadata_ =
xplane_.GetEventMetadata(kThreadpoolListenerStartRegion);
stop_region_metadata_ =
xplane_.GetEventMetadata(kThreadpoolListenerStopRegion);
thread_pool_metadata_ =
xplane_.GetOrCreateEventMetadata(kThreadpoolListenerRegion);
consumer_ = xplane_.GetOrCreateStatMetadata(
GetStatTypeStr(StatType::kConsumerId));
consumer_type_ = xplane_.GetOrCreateStatMetadata(
GetStatTypeStr(StatType::kConsumerType));
}
void Mutate(XEventBuilder& event_builder) override {
CHECK(false);
}
void MutateEventsInLine(XLineBuilder& line) override {
if (start_region_metadata_ == nullptr ||
stop_region_metadata_ == nullptr) {
return;
}
int64_t start_region_timestamp_ps = 0;
int64_t region_id;
struct EventMetadata {
int64_t start_region_timestamp_ps;
int64_t region_id;
int64_t end_region_timestamp_ps;
};
std::vector<EventMetadata> event_metadata;
line.ForEachEvent([&](const XEventBuilder& event) {
if (event.MetadataId() == start_region_metadata_->id()) {
auto consumer_id = event.GetStat(*consumer_);
if (!consumer_id) return;
start_region_timestamp_ps = event.TimestampPs();
region_id = event.IntOrUintValue(*consumer_id);
} else if (event.MetadataId() == stop_region_metadata_->id() &&
start_region_timestamp_ps != 0) {
EventMetadata metadata;
metadata.start_region_timestamp_ps = start_region_timestamp_ps;
metadata.region_id = region_id;
metadata.end_region_timestamp_ps = event.TimestampPs();
event_metadata.emplace_back(metadata);
}
});
for (const auto& event_metadata : event_metadata) {
XEventBuilder region = line.AddEvent(*thread_pool_metadata_);
region.SetTimestampPs(event_metadata.start_region_timestamp_ps);
region.SetEndTimestampPs(event_metadata.end_region_timestamp_ps);
region.SetOrAddStatValue(*consumer_, event_metadata.region_id);
region.SetOrAddStatValue(
*consumer_type_,
static_cast<int64_t>(ContextType::kThreadpoolEvent));
}
}
private:
XStatMetadata* consumer_;
XStatMetadata* consumer_type_;
XPlaneBuilder& xplane_;
XEventMetadata* start_region_metadata_;
XEventMetadata* stop_region_metadata_;
XEventMetadata* thread_pool_metadata_;
};
};
void PreprocessXSpace(XSpace* space);
void PreprocessXPlane(XPlane* plane);
}
}
#endif
#include "tsl/profiler/utils/preprocess_xplane.h"
#include <cstdint>
#include <memory>
#include <utility>
#include <vector>
#include "absl/container/flat_hash_map.h"
#include "tsl/profiler/lib/context_types.h"
#include "tsl/profiler/protobuf/xplane.pb.h"
#include "tsl/profiler/utils/xplane_builder.h"
#include "tsl/profiler/utils/xplane_schema.h"
namespace tsl {
namespace profiler {
namespace {
using ::tsl::profiler::HostEventType;
using ::tsl::profiler::StatType;
using ::tsl::profiler::XEventBuilder;
using ::tsl::profiler::XLineBuilder;
using ::tsl::profiler::XPlane;
using ::tsl::profiler::XPlaneBuilder;
using ::tsl::profiler::XSpace;
void MutateXPlane(XPlane& plane,
const std::vector<std::unique_ptr<XplaneEventMutatorFactory>>&
mutator_factories) {
XPlaneBuilder plane_builder(&plane);
absl::flat_hash_map<int64_t, std::vector<std::unique_ptr<XplaneEventMutator>>>
mutators_from_event_metadata_id;
std::vector<std::unique_ptr<XplaneEventMutator>> line_mutators;
for (const auto& mutator_factory : mutator_factories) {
auto mutators = mutator_factory->CreateMutators(plane_builder);
for (auto& mutator : mutators) {
if (mutator->event_metadata()) {
auto id = mutator->event_metadata()->id();
mutators_from_event_metadata_id[id].push_back(std::move(mutator));
} else {
line_mutators.push_back(std::move(mutator));
}
}
}
if (mutators_from_event_metadata_id.empty() && line_mutators.empty()) {
return;
}
plane_builder.ForEachLine([&](XLineBuilder line_builder) {
for (const auto& mutator : line_mutators) {
mutator->MutateEventsInLine(line_builder);
}
if (mutators_from_event_metadata_id.empty()) return;
line_builder.ForEachEvent([&](XEventBuilder event_builder) {
auto event_mutators =
mutators_from_event_metadata_id.find(event_builder.MetadataId());
if (event_mutators != mutators_from_event_metadata_id.end()) {
for (const auto& mutator : event_mutators->second) {
mutator->Mutate(event_builder);
}
}
});
});
}
std::vector<std::unique_ptr<XplaneEventMutatorFactory>>
CreateMutatorFactories() {
std::vector<std::unique_ptr<XplaneEventMutatorFactory>> mutator_factories;
mutator_factories.push_back(ThreadpoolLineMutatorFactory::CreateFactory());
mutator_factories.push_back(XplaneRootEventMutatorFactory::CreateFactory(
HostEventType::kProcessBatch, 2));
mutator_factories.push_back(XplaneRootEventMutatorFactory::CreateFactory(
HostEventType::kBatchingSessionRun, 1));
mutator_factories.push_back(
XplaneConnectedEventMutatorFactory<
HostEventType::kExecutorStateProcess,
HostEventType::kTpuExecuteOp, ContextType::kLegacy,
false,
XContextStatsAccessor<uint64_t, StatType::kStepId>,
XContextStatsAccessor<uint64_t,
StatType::kIterNum>>::CreateFactory());
#define ADD_QUEUE_CONNECTION(__enque_event__, __deque_event__) \
mutator_factories.push_back( \
XplaneConnectedEventMutatorFactory< \
HostEventType::__enque_event__, HostEventType::__deque_event__, \
ContextType::kTpuStream, true, \
XContextStatsAccessor<uint64, StatType::kRequestId>, \
XContextStatsAccessor<uint64, \
StatType::kQueueAddr>>::CreateFactory())
ADD_QUEUE_CONNECTION(kEnqueueRequestLocked, kRunProgramRequest);
ADD_QUEUE_CONNECTION(kEnqueueRequestLocked, kHostCallbackRequest);
ADD_QUEUE_CONNECTION(kEnqueueRequestLocked, kTransferH2DRequest);
ADD_QUEUE_CONNECTION(kEnqueueRequestLocked, kTransferPreprocessedH2DRequest);
ADD_QUEUE_CONNECTION(kEnqueueRequestLocked, kTransferD2HRequest);
ADD_QUEUE_CONNECTION(kEnqueueRequestLocked, kOnDeviceSendRequest);
ADD_QUEUE_CONNECTION(kEnqueueRequestLocked, kOnDeviceRecvRequest);
ADD_QUEUE_CONNECTION(kEnqueueRequestLocked, kOnDeviceSendRecvLocalRequest);
ADD_QUEUE_CONNECTION(kEnqueueRequestLocked, kCustomWait);
ADD_QUEUE_CONNECTION(kEnqueueRequestLocked, kOnDeviceSendRequestMulti);
ADD_QUEUE_CONNECTION(kEnqueueRequestLocked, kOnDeviceRecvRequestMulti);
ADD_QUEUE_CONNECTION(kEnqueueRequestLocked, kPjrtAsyncWait);
#undef ADD_QUEUE_CONNECTION
mutator_factories.push_back(
HostRunIdMutatorFactory<
HostEventType::kDoEnqueueProgram>::CreateFactory());
mutator_factories.push_back(
HostRunIdMutatorFactory<
HostEventType::kCompleteCallbacks>::CreateFactory());
mutator_factories.push_back(
HostRunIdMutatorFactory<
HostEventType::kDoEnqueueContinuationProgram>::CreateFactory());
mutator_factories.push_back(
XplaneConnectedEventMutatorFactory<
HostEventType::kDoEnqueueProgram,
HostEventType::kCompleteCallbacks,
ContextType::kTpuLaunch,
true,
XContextStatsAccessor<uint64_t, StatType::kDeviceOrdinal>,
XContextStatsAccessor<uint64_t, StatType::kQueueId>,
XContextStatsAccessor<uint64_t, StatType::kRunId>,
XContextStatsAccessorWithDefault<uint64_t, StatType::kCoreType,
0ULL>>::CreateFactory());
mutator_factories.push_back(TpuModuleLineMutatorFactory::CreateFactory());
return mutator_factories;
}
}
void PreprocessXPlane(XPlane* plane) {
if (plane == nullptr) return;
auto mutator_factories = CreateMutatorFactories();
MutateXPlane(*plane, mutator_factories);
}
void PreprocessXSpace(XSpace* space) {
if (space == nullptr) return;
auto mutator_factories = CreateMutatorFactories();
for (XPlane& plane : *space->mutable_planes()) {
MutateXPlane(plane, mutator_factories);
}
}
}
} | #include "tsl/profiler/utils/preprocess_xplane.h"
#include <cstdint>
#include <memory>
#include <optional>
#include "absl/container/flat_hash_map.h"
#include "absl/hash/hash.h"
#include "tsl/platform/test.h"
#include "tsl/profiler/lib/connected_traceme.h"
#include "tsl/profiler/protobuf/xplane.pb.h"
#include "tsl/profiler/utils/tf_xplane_visitor.h"
#include "tsl/profiler/utils/xplane_builder.h"
#include "tsl/profiler/utils/xplane_schema.h"
#include "tsl/profiler/utils/xplane_test_utils.h"
#include "tsl/profiler/utils/xplane_visitor.h"
namespace tsl {
namespace profiler {
namespace {
using ::tsl::profiler::CreateTfXPlaneVisitor;
using ::tsl::profiler::CreateXEvent;
using ::tsl::profiler::GetHostEventTypeStr;
using ::tsl::profiler::HostEventType;
using ::tsl::profiler::StatType;
using ::tsl::profiler::XEventVisitor;
using ::tsl::profiler::XLineVisitor;
using ::tsl::profiler::XPlane;
using ::tsl::profiler::XPlaneBuilder;
using ::tsl::profiler::XPlaneVisitor;
using ::tsl::profiler::XSpace;
TEST(PreprocessXPlane, IsRootStatsTest) {
XSpace space;
XPlane* plane = space.add_planes();
XPlaneBuilder plane_builder(plane);
plane_builder.ReserveLines(1);
auto line_builder = plane_builder.GetOrCreateLine(0);
CreateXEvent(&plane_builder, &line_builder,
GetHostEventTypeStr(HostEventType::kProcessBatch), 100, 100);
CreateXEvent(&plane_builder, &line_builder,
GetHostEventTypeStr(HostEventType::kBatchingSessionRun), 200,
100);
PreprocessXSpace(&space);
XPlaneVisitor plane_visitor = CreateTfXPlaneVisitor(plane);
plane_visitor.ForEachLine([&](const XLineVisitor& line) {
line.ForEachEvent([&](const XEventVisitor& event) {
ASSERT_TRUE(event.GetStat(StatType::kIsRoot).has_value());
int64_t is_root = event.GetStat(StatType::kIsRoot)->IntValue();
if (event.Type() == HostEventType::kBatchingSessionRun) {
EXPECT_EQ(is_root, 1);
} else if (event.Type() == HostEventType::kProcessBatch) {
EXPECT_EQ(is_root, 2);
} else {
CHECK(false);
}
});
});
}
TEST(PreprocessXPlane, ProducerConsumerTest) {
XSpace space;
XPlane* plane = space.add_planes();
XPlaneBuilder plane_builder(plane);
plane_builder.ReserveLines(2);
auto line_builder = plane_builder.GetOrCreateLine(0);
CreateXEvent(
&plane_builder, &line_builder,
GetHostEventTypeStr(HostEventType::kExecutorStateProcess), 100, 100,
{{StatType::kStepId, int64_t{123}}, {StatType::kIterNum, int64_t{456}}});
line_builder = plane_builder.GetOrCreateLine(1);
CreateXEvent(
&plane_builder, &line_builder,
GetHostEventTypeStr(HostEventType::kTpuExecuteOp), 200, 100,
{{StatType::kStepId, int64_t{123}}, {StatType::kIterNum, int64_t{456}}});
PreprocessXSpace(&space);
std::optional<uint64_t> producer_context_id, consumer_context_id;
XPlaneVisitor plane_visitor = CreateTfXPlaneVisitor(plane);
plane_visitor.ForEachLine([&](const XLineVisitor& line) {
line.ForEachEvent([&](const XEventVisitor& event) {
if (event.Type() == HostEventType::kExecutorStateProcess) {
auto producer_type = event.GetStat(StatType::kProducerType);
ASSERT_TRUE(producer_type.has_value());
EXPECT_EQ(producer_type->IntValue(),
static_cast<int64_t>(ContextType::kLegacy));
auto producer_id = event.GetStat(StatType::kProducerId);
ASSERT_TRUE(producer_id.has_value());
producer_context_id = producer_id->IntOrUintValue();
} else if (event.Type() == HostEventType::kTpuExecuteOp) {
auto consumer_type = event.GetStat(StatType::kConsumerType);
ASSERT_TRUE(consumer_type.has_value());
EXPECT_EQ(consumer_type->IntValue(),
static_cast<int64_t>(ContextType::kLegacy));
auto consumer_id = event.GetStat(StatType::kConsumerId);
ASSERT_TRUE(consumer_id.has_value());
consumer_context_id = consumer_id->IntOrUintValue();
} else {
CHECK(false);
}
});
});
ASSERT_TRUE(producer_context_id && consumer_context_id);
ASSERT_EQ(*producer_context_id, *consumer_context_id);
}
TEST(PreprocessXPlane, ProducerConsumerNotMatchedTest) {
XSpace space;
XPlane* plane = space.add_planes();
XPlaneBuilder plane_builder(plane);
plane_builder.ReserveLines(2);
auto line_builder = plane_builder.GetOrCreateLine(0);
CreateXEvent(&plane_builder, &line_builder,
GetHostEventTypeStr(HostEventType::kExecutorStateProcess), 100,
100,
{{StatType::kStepId, int64_t{123}},
{StatType::kIterNum, int64_t{456}},
{StatType::kDeviceOrdinal, int64_t{789}}});
line_builder = plane_builder.GetOrCreateLine(1);
CreateXEvent(
&plane_builder, &line_builder,
GetHostEventTypeStr(HostEventType::kTpuExecuteOp), 200, 100,
{{StatType::kStepId, int64_t{123}}, {StatType::kIterNum, int64_t{789}}});
PreprocessXSpace(&space);
std::optional<uint64_t> producer_context_id, consumer_context_id;
XPlaneVisitor plane_visitor = CreateTfXPlaneVisitor(plane);
plane_visitor.ForEachLine([&](const XLineVisitor& line) {
line.ForEachEvent([&](const XEventVisitor& event) {
if (event.Type() == HostEventType::kExecutorStateProcess) {
auto producer_type = event.GetStat(StatType::kProducerType);
ASSERT_TRUE(producer_type.has_value());
EXPECT_EQ(producer_type->IntValue(),
static_cast<int64_t>(ContextType::kLegacy));
auto producer_id = event.GetStat(StatType::kProducerId);
ASSERT_TRUE(producer_id.has_value());
producer_context_id = producer_id->IntOrUintValue();
} else if (event.Type() == HostEventType::kTpuExecuteOp) {
auto consumer_type = event.GetStat(StatType::kConsumerType);
ASSERT_TRUE(consumer_type.has_value());
EXPECT_EQ(consumer_type->IntValue(),
static_cast<int64_t>(ContextType::kLegacy));
auto consumer_id = event.GetStat(StatType::kConsumerId);
ASSERT_TRUE(consumer_id.has_value());
consumer_context_id = consumer_id->IntOrUintValue();
} else {
CHECK(false);
}
});
});
ASSERT_TRUE(producer_context_id && consumer_context_id);
ASSERT_NE(*producer_context_id, *consumer_context_id);
}
TEST(PreprocessXPlane, MissingLegacyStatTest) {
XSpace space;
XPlane* plane = space.add_planes();
XPlaneBuilder plane_builder(plane);
plane_builder.ReserveLines(2);
auto line_builder = plane_builder.GetOrCreateLine(0);
CreateXEvent(&plane_builder, &line_builder,
GetHostEventTypeStr(HostEventType::kExecutorStateProcess), 100,
100, {{StatType::kStepId, int64_t{123}}});
line_builder = plane_builder.GetOrCreateLine(1);
CreateXEvent(&plane_builder, &line_builder,
GetHostEventTypeStr(HostEventType::kTpuExecuteOp), 200, 100,
{{StatType::kStepId, int64_t{123}}});
PreprocessXSpace(&space);
XPlaneVisitor plane_visitor = CreateTfXPlaneVisitor(plane);
plane_visitor.ForEachLine([&](const XLineVisitor& line) {
line.ForEachEvent([&](const XEventVisitor& event) {
if (event.Type() == HostEventType::kExecutorStateProcess) {
auto producer_type = event.GetStat(StatType::kProducerType);
ASSERT_FALSE(producer_type.has_value());
auto producer_id = event.GetStat(StatType::kProducerId);
ASSERT_FALSE(producer_id.has_value());
} else if (event.Type() == HostEventType::kTpuExecuteOp) {
auto consumer_type = event.GetStat(StatType::kConsumerType);
ASSERT_FALSE(consumer_type.has_value());
auto consumer_id = event.GetStat(StatType::kConsumerId);
ASSERT_FALSE(consumer_id.has_value());
} else {
CHECK(false);
}
});
});
}
TEST(PreprocessXPlane, HostRunIdPreprocessorTest) {
XSpace space;
XPlane* plane = space.add_planes();
XPlaneBuilder plane_builder(plane);
plane_builder.ReserveLines(2);
auto line_builder = plane_builder.GetOrCreateLine(0);
int64_t host_run_id = int64_t{582974244};
int64_t device_run_id = int64_t{46103332};
CreateXEvent(
&plane_builder, &line_builder,
GetHostEventTypeStr(HostEventType::kDoEnqueueContinuationProgram), 100,
100, {});
CreateXEvent(&plane_builder, &line_builder,
GetHostEventTypeStr(HostEventType::kDoEnqueueProgram), 100, 100,
{{StatType::kRunId, int64_t{host_run_id}}});
CreateXEvent(&plane_builder, &line_builder,
GetHostEventTypeStr(HostEventType::kTpuExecuteOp), 200, 100,
{{StatType::kRunId, int64_t{device_run_id}}});
CreateXEvent(&plane_builder, &line_builder,
GetHostEventTypeStr(HostEventType::kCompleteCallbacks), 300, 100,
{{StatType::kRunId, int64_t{host_run_id}}});
line_builder = plane_builder.GetOrCreateLine(1);
PreprocessXSpace(&space);
XPlaneVisitor plane_visitor = CreateTfXPlaneVisitor(plane);
plane_visitor.ForEachLine([&](const XLineVisitor& line) {
line.ForEachEvent([&](const XEventVisitor& event) {
if (event.Type() == HostEventType::kDoEnqueueContinuationProgram) {
auto run_id = event.GetStat(StatType::kRunId);
ASSERT_FALSE(run_id.has_value());
} else if (event.Type() == HostEventType::kDoEnqueueProgram) {
auto run_id = event.GetStat(StatType::kRunId);
ASSERT_TRUE(run_id.has_value());
ASSERT_EQ(run_id->IntValue(), device_run_id);
} else if (event.Type() == HostEventType::kTpuExecuteOp) {
auto run_id = event.GetStat(StatType::kRunId);
ASSERT_TRUE(run_id.has_value());
ASSERT_EQ(run_id->IntValue(), device_run_id);
} else if (event.Type() == HostEventType::kCompleteCallbacks) {
auto run_id = event.GetStat(StatType::kRunId);
ASSERT_TRUE(run_id.has_value());
ASSERT_EQ(run_id->IntValue(), device_run_id);
} else {
CHECK(false);
}
});
});
}
TEST(PreprocessXPlane, ThreadPoolPreprocessorTest) {
XSpace space;
XPlane* plane = space.add_planes();
XPlaneBuilder plane_builder(plane);
auto main_line = plane_builder.GetOrCreateLine(0);
CreateXEvent(&plane_builder, &main_line, kThreadpoolListenerRecord, 100, 100,
{{StatType::kProducerType,
static_cast<int64_t>(ContextType::kThreadpoolEvent)},
{StatType::kProducerId, int64_t{123}}});
auto thread_pool_line = plane_builder.GetOrCreateLine(1);
CreateXEvent(&plane_builder, &thread_pool_line,
kThreadpoolListenerStartRegion, 200, 0,
{{StatType::kConsumerType,
static_cast<int64_t>(ContextType::kThreadpoolEvent)},
{StatType::kConsumerId, int64_t{123}}});
CreateXEvent(&plane_builder, &thread_pool_line, kThreadpoolListenerStopRegion,
300, 0,
{{StatType::kConsumerType,
static_cast<int64_t>(ContextType::kThreadpoolEvent)},
{StatType::kConsumerId, int64_t{123}}});
bool new_event_added = false;
PreprocessXSpace(&space);
XPlaneVisitor plane_visitor = CreateTfXPlaneVisitor(plane);
plane_visitor.ForEachLine([&](const XLineVisitor& line) {
line.ForEachEvent([&](const XEventVisitor& event) {
if (event.Name() == kThreadpoolListenerRegion) {
new_event_added = true;
EXPECT_EQ(event.DurationPs(), 100);
EXPECT_EQ(event.TimestampPs(), 200);
auto stat = event.GetStat(StatType::kConsumerId);
EXPECT_TRUE(stat.has_value());
EXPECT_EQ(stat->IntOrUintValue(), 123);
}
});
});
EXPECT_TRUE(new_event_added);
}
TEST(PreprocessXPlane, XContextStatsAccessorNPETest) {
auto xplane = std::make_unique<XPlane>();
XPlaneBuilder xplane_builder(xplane.get());
XLine xline;
XLineBuilder xline_builder(&xline, &xplane_builder);
XEvent xevent;
XEventBuilder xevent_builder(&xline, &xplane_builder, &xevent);
XContextStatsAccessor<int64_t, StatType::kRunId> run_id_accessor;
ASSERT_FALSE(run_id_accessor.Initialize(xplane_builder));
EXPECT_EQ(run_id_accessor.GetStat(xevent_builder), std::nullopt);
}
}
}
} |
2,628 | cpp | google/tsl | tf_op_utils | tsl/profiler/utils/tf_op_utils.cc | tsl/profiler/utils/tf_op_utils_test.cc | #ifndef TENSORFLOW_TSL_PROFILER_UTILS_TF_OP_UTILS_H_
#define TENSORFLOW_TSL_PROFILER_UTILS_TF_OP_UTILS_H_
#include <string>
#include <vector>
#include "absl/strings/match.h"
#include "absl/strings/string_view.h"
#include "tsl/platform/macros.h"
namespace tsl {
namespace profiler {
TF_CONST_INIT extern const absl::string_view kUnknownOp;
TF_CONST_INIT extern const absl::string_view kDatasetOp;
TF_CONST_INIT extern const absl::string_view kMemcpyHToDOp;
TF_CONST_INIT extern const absl::string_view kMemcpyDToHOp;
TF_CONST_INIT extern const absl::string_view kMemcpyDToDOp;
TF_CONST_INIT extern const absl::string_view kMemcpyHToHOp;
enum class Category {
kUnknown,
kTensorFlow,
kJax,
kTfData,
kMemcpyHToD,
kMemcpyDToH,
kMemcpyDToD,
kMemcpyHToH,
};
struct TfOp {
Category category = Category::kUnknown;
absl::string_view name;
absl::string_view type;
};
TfOp ParseTfOpFullname(absl::string_view tf_op_fullname);
std::vector<absl::string_view> ParseTfNameScopes(absl::string_view tf_op_name);
std::vector<absl::string_view> ParseTfNameScopes(const TfOp& tf_op);
std::string TfOpEventName(const TfOp& tf_op);
std::string TfOpEventName(absl::string_view tf_op_fullname);
std::string DatasetOpEventName(absl::string_view full_name);
std::string IteratorName(absl::string_view full_name);
inline bool IsDatasetOp(absl::string_view tf_op_type) {
return tf_op_type == kDatasetOp;
}
inline bool IsDatasetOp(const TfOp& tf_op) {
return tf_op.category == Category::kTfData;
}
inline bool IsInfeedEnqueueOp(absl::string_view tf_op_type) {
return absl::StartsWith(tf_op_type, "InfeedEnqueue");
}
inline bool IsInfeedEnqueueOp(const TfOp& tf_op) {
return tf_op.category == Category::kTensorFlow &&
IsInfeedEnqueueOp(tf_op.type);
}
inline bool IsOutsideCompilationOp(absl::string_view tf_op_fullname) {
if (absl::EndsWith(tf_op_fullname, ":XlaSendToHost")) return true;
if (absl::EndsWith(tf_op_fullname, ":XlaRecvFromHost")) return true;
return false;
}
inline bool IsOutsideCompilationOp(absl::string_view tf_op_fullname,
absl::string_view hlo_expression) {
if (IsOutsideCompilationOp(tf_op_fullname)) return true;
if (absl::StrContains(hlo_expression, "send-done") &&
absl::StrContains(hlo_expression, "is_host_transfer=true"))
return true;
return false;
}
inline bool IsEmbeddingOp(absl::string_view tf_op_fullname) {
return absl::StrContains(tf_op_fullname, "Embedding");
}
inline bool IsMemcpyHToDOp(absl::string_view tf_op_type) {
return tf_op_type == kMemcpyHToDOp;
}
inline bool IsMemcpyHToDOp(const TfOp& tf_op) {
return tf_op.category == Category::kMemcpyHToD;
}
inline bool IsMemcpyDToHOp(const TfOp& tf_op) {
return tf_op.category == Category::kMemcpyDToH;
}
inline bool IsMemcpyDToDOp(const TfOp& tf_op) {
return tf_op.category == Category::kMemcpyDToD;
}
inline bool IsMemcpyHToHOp(const TfOp& tf_op) {
return tf_op.category == Category::kMemcpyHToH;
}
std::vector<absl::string_view> ParseTensorShapes(
absl::string_view tensor_shapes);
bool IsTfOpName(absl::string_view op_name);
bool IsTfOpType(absl::string_view op_type);
bool IsJaxOpType(absl::string_view op_type);
bool IsJaxOpNameAndType(absl::string_view op_name, absl::string_view op_type);
}
}
#endif
#include "tsl/profiler/utils/tf_op_utils.h"
#include <cstdint>
#include <optional>
#include <string>
#include <vector>
#include "absl/strings/ascii.h"
#include "absl/strings/match.h"
#include "absl/strings/numbers.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_split.h"
#include "absl/strings/string_view.h"
#include "absl/strings/strip.h"
#include "tsl/platform/regexp.h"
namespace tsl {
namespace profiler {
namespace {
const absl::string_view kIterator = "Iterator";
const absl::string_view kSeparator = "::";
constexpr char kNameScopeSeparator = '/';
constexpr char kOpNameSuffixSeparator = '_';
bool IsInteger(absl::string_view str) {
int64_t unused;
return absl::SimpleAtoi(str, &unused);
}
absl::string_view DeriveOpType(absl::string_view full_op_name) {
std::vector<absl::string_view> name_scopes_and_op_name =
absl::StrSplit(full_op_name, kNameScopeSeparator);
absl::string_view op_name = name_scopes_and_op_name.back();
std::vector<absl::string_view> op_type_and_maybe_suffix =
absl::StrSplit(op_name, kOpNameSuffixSeparator);
absl::string_view maybe_suffix = op_type_and_maybe_suffix.back();
absl::string_view op_type = op_name;
if (IsInteger(maybe_suffix)) {
op_type = op_name.substr(0, op_name.size() - maybe_suffix.size() - 1);
}
return op_type;
}
std::optional<TfOp> GetMemcpyOp(absl::string_view tf_op_fullname) {
TfOp tf_op;
tf_op.name = tf_op_fullname;
if (absl::StartsWithIgnoreCase(tf_op_fullname, "MEMCPYHToD")) {
tf_op.category = Category::kMemcpyHToD;
tf_op.type = kMemcpyHToDOp;
return tf_op;
}
if (absl::StartsWithIgnoreCase(tf_op_fullname, "MEMCPYDToH")) {
tf_op.category = Category::kMemcpyDToH;
tf_op.type = kMemcpyDToHOp;
return tf_op;
}
if (absl::StartsWithIgnoreCase(tf_op_fullname, "MEMCPYDToD")) {
tf_op.category = Category::kMemcpyDToD;
tf_op.type = kMemcpyDToDOp;
return tf_op;
} else if (absl::StartsWithIgnoreCase(tf_op_fullname, "MEMCPYHToH")) {
tf_op.category = Category::kMemcpyHToH;
tf_op.type = kMemcpyHToHOp;
return tf_op;
}
return std::nullopt;
}
}
const absl::string_view kUnknownOp = "";
const absl::string_view kDatasetOp = "Dataset";
const absl::string_view kMemcpyHToDOp = "MemcpyHToD";
const absl::string_view kMemcpyDToHOp = "MemcpyDToH";
const absl::string_view kMemcpyDToDOp = "MemcpyDToD";
const absl::string_view kMemcpyHToHOp = "MemcpyHToH";
bool IsTfOpName(absl::string_view op_name) {
static const LazyRE2 kTfOpNameRegEx = {"[A-Za-z0-9.][A-Za-z0-9_.\\/>-]*"};
return RE2::FullMatch(op_name, *kTfOpNameRegEx);
}
bool IsTfOpType(absl::string_view op_type) {
static const LazyRE2 kTfOpTypeRegEx = {"[A-Z_][a-zA-Z0-9_]*"};
return RE2::FullMatch(op_type, *kTfOpTypeRegEx);
}
bool IsJaxOpType(absl::string_view op_type) {
static const LazyRE2 kJaxOpTypeRegEx = {"[a-z_][a-z0-9_]*(\\[.*\\])?"};
return RE2::FullMatch(op_type, *kJaxOpTypeRegEx);
}
bool IsJaxOpNameAndType(absl::string_view op_name, absl::string_view op_type) {
if (op_name.empty() || !IsJaxOpType(op_type)) return false;
std::vector<absl::string_view> split_result =
absl::StrSplit(op_name, kNameScopeSeparator);
return absl::StrContains(split_result.back(), op_type);
}
TfOp ParseTfOpFullname(absl::string_view tf_op_fullname) {
TfOp tf_op = {Category::kUnknown, tf_op_fullname, kUnknownOp};
std::vector<absl::string_view> parts =
absl::StrSplit(tf_op_fullname, absl::MaxSplits(':', 1));
if (parts.size() != 2) {
if (std::optional<TfOp> tfop = GetMemcpyOp(parts[0]); tfop.has_value()) {
return *tfop;
}
return tf_op;
}
if (parts[0] == kIterator) {
tf_op.category = Category::kTfData;
tf_op.type = kDatasetOp;
return tf_op;
}
if (IsTfOpName(parts[0]) && IsTfOpType(parts[1])) {
tf_op.category = Category::kTensorFlow;
tf_op.name = parts[0];
tf_op.type = parts[1];
return tf_op;
}
absl::string_view op_type =
parts[1].empty() ? DeriveOpType(parts[0]) : parts[1];
if (IsJaxOpType(op_type)) {
tf_op.category = Category::kJax;
tf_op.name = parts[0];
tf_op.type = op_type.substr(0, op_type.find('['));
return tf_op;
}
if (parts[1].empty()) {
tf_op.category = Category::kTensorFlow;
tf_op.name = parts[0];
tf_op.type = op_type;
return tf_op;
}
return tf_op;
}
std::vector<absl::string_view> ParseTfNameScopes(absl::string_view tf_op_name) {
std::vector<absl::string_view> name_scopes =
absl::StrSplit(tf_op_name, kNameScopeSeparator);
if (!name_scopes.empty()) name_scopes.pop_back();
return name_scopes;
}
std::vector<absl::string_view> ParseTfNameScopes(const TfOp& tf_op) {
return ParseTfNameScopes(tf_op.name);
}
std::string TfOpEventName(const TfOp& tf_op) {
std::string event_name;
if (tf_op.category == Category::kUnknown) {
event_name = std::string(absl::StripTrailingAsciiWhitespace(tf_op.name));
} else if (tf_op.category == Category::kTfData) {
event_name = DatasetOpEventName(tf_op.name);
} else {
event_name = std::string(tf_op.type);
}
return event_name;
}
std::string TfOpEventName(absl::string_view tf_op_fullname) {
return TfOpEventName(ParseTfOpFullname(tf_op_fullname));
}
std::string DatasetOpEventName(absl::string_view full_name) {
std::vector<absl::string_view> split_result =
absl::StrSplit(full_name, kSeparator);
return absl::StrCat(kIterator, kSeparator, split_result.back());
}
std::string IteratorName(absl::string_view full_name) {
std::vector<absl::string_view> split_result =
absl::StrSplit(full_name, kSeparator);
return std::string(split_result.back());
}
std::vector<absl::string_view> ParseTensorShapes(
absl::string_view tensor_shapes) {
absl::ConsumePrefix(&tensor_shapes, "(");
absl::ConsumeSuffix(&tensor_shapes, ")");
return absl::StrSplit(tensor_shapes, ';');
}
}
} | #include "tsl/profiler/utils/tf_op_utils.h"
#include <vector>
#include "absl/strings/string_view.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace profiler {
namespace {
TEST(TfOpUtilsTest, TfOpTest) {
const absl::string_view kName = "OpName:OpType";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kTensorFlow);
EXPECT_EQ(tf_op.name, "OpName");
EXPECT_EQ(tf_op.type, "OpType");
EXPECT_EQ(TfOpEventName(kName), "OpType");
}
TEST(TfOpUtilsTest, InternalTfOpTest) {
const absl::string_view kName = "OpName:_InternalOpType";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kTensorFlow);
EXPECT_EQ(tf_op.name, "OpName");
EXPECT_EQ(tf_op.type, "_InternalOpType");
EXPECT_EQ(TfOpEventName(kName), "_InternalOpType");
}
TEST(TfOpUtilsTest, TfOpWithPathTest) {
const absl::string_view kName = "path/to/name:OpType";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kTensorFlow);
EXPECT_EQ(tf_op.name, "path/to/name");
EXPECT_EQ(tf_op.type, "OpType");
EXPECT_EQ(TfOpEventName(kName), "OpType");
}
TEST(TfOpUtilsTest, ShortDatasetOpTest) {
const absl::string_view kName = "Iterator::Batch";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kTfData);
EXPECT_EQ(tf_op.name, kName);
EXPECT_EQ(tf_op.type, kDatasetOp);
EXPECT_EQ(TfOpEventName(kName), kName);
}
TEST(TfOpUtilsTest, LongDatasetOpTest) {
const absl::string_view kName = "Iterator::Batch::Map::TfRecord";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kTfData);
EXPECT_EQ(tf_op.name, kName);
EXPECT_EQ(tf_op.type, kDatasetOp);
EXPECT_EQ(TfOpEventName(kName), "Iterator::TfRecord");
}
TEST(TfOpUtilsTest, TraceMeTest) {
const absl::string_view kName = "MyTraceMe";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kUnknown);
EXPECT_EQ(tf_op.name, kName);
EXPECT_EQ(tf_op.type, kUnknownOp);
EXPECT_EQ(TfOpEventName(kName), kName);
}
TEST(TfOpUtilsTest, TraceMeWithColonTest) {
const absl::string_view kName = "RunStep/Server:54635";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kUnknown);
EXPECT_EQ(tf_op.name, kName);
EXPECT_EQ(tf_op.type, kUnknownOp);
EXPECT_EQ(TfOpEventName(kName), kName);
}
TEST(TfOpUtilsTest, TraceMeWithDoubleColonTest) {
const absl::string_view kName = "XLA::StartProgram";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kUnknown);
EXPECT_EQ(tf_op.name, kName);
EXPECT_EQ(tf_op.type, kUnknownOp);
EXPECT_EQ(TfOpEventName(kName), kName);
}
TEST(TfOpUtilsTest, TraceMeWithTrailingWhitespaceTest) {
const absl::string_view kName = "SessionRun ";
const absl::string_view kNameTrimmed = "SessionRun";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kUnknown);
EXPECT_EQ(tf_op.name, kName);
EXPECT_EQ(tf_op.type, kUnknownOp);
EXPECT_EQ(TfOpEventName(kName), kNameTrimmed);
}
TEST(TfOpUtilsTest, InfeedEnqueueTest) {
const absl::string_view kName =
"input_pipeline_task0/while/body/_1/InfeedQueue/enqueue/"
"1:InfeedEnqueueTuple";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kTensorFlow);
EXPECT_EQ(tf_op.name,
"input_pipeline_task0/while/body/_1/InfeedQueue/enqueue/1");
EXPECT_EQ(tf_op.type, "InfeedEnqueueTuple");
EXPECT_EQ(TfOpEventName(kName), "InfeedEnqueueTuple");
EXPECT_TRUE(IsInfeedEnqueueOp(tf_op.type));
EXPECT_TRUE(IsInfeedEnqueueOp(tf_op));
}
TEST(TfOpUtilsTest, MemcpyHToDTest) {
const absl::string_view kName = "MemcpyHToD";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kMemcpyHToD);
EXPECT_EQ(tf_op.name, kName);
EXPECT_EQ(tf_op.type, kMemcpyHToDOp);
EXPECT_EQ(TfOpEventName(kName), kName);
EXPECT_TRUE(IsMemcpyHToDOp(tf_op.type));
EXPECT_TRUE(IsMemcpyHToDOp(tf_op));
}
TEST(TfOpUtilsTest, MemcpyDToHTest) {
const absl::string_view kName = "MemcpyDToH";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kMemcpyDToH);
EXPECT_EQ(tf_op.name, kName);
EXPECT_EQ(tf_op.type, kMemcpyDToHOp);
EXPECT_EQ(TfOpEventName(kName), kName);
EXPECT_TRUE(IsMemcpyDToHOp(tf_op));
}
TEST(TfOpUtilsTest, MemcpyDToDTest) {
const absl::string_view kName = "MemcpyDToD";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kMemcpyDToD);
EXPECT_EQ(tf_op.name, kName);
EXPECT_EQ(tf_op.type, kMemcpyDToDOp);
EXPECT_EQ(TfOpEventName(kName), kName);
EXPECT_TRUE(IsMemcpyDToDOp(tf_op));
}
TEST(TfOpUtilsTest, MemcpyHToHTest) {
const absl::string_view kName = "MemcpyHToH";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kMemcpyHToH);
EXPECT_EQ(tf_op.name, kName);
EXPECT_EQ(tf_op.type, kMemcpyHToHOp);
EXPECT_EQ(TfOpEventName(kName), kName);
EXPECT_TRUE(IsMemcpyHToHOp(tf_op));
}
TEST(TfOpUtilsTest, JaxOpTest) {
const absl::string_view kName = "op_name:op_type";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kJax);
EXPECT_EQ(tf_op.name, "op_name");
EXPECT_EQ(tf_op.type, "op_type");
EXPECT_EQ(TfOpEventName(kName), "op_type");
}
TEST(TfOpUtilsTest, JaxOpWithColonTest) {
const absl::string_view kName = "op_name/op_type:";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kJax);
EXPECT_EQ(tf_op.name, "op_name/op_type");
EXPECT_EQ(tf_op.type, "op_type");
EXPECT_EQ(TfOpEventName(kName), "op_type");
}
TEST(TfOpUtilsTest, JaxOpNameTest) {
const absl::string_view kOpName = "namescope/add";
const absl::string_view kOpType = "add";
EXPECT_TRUE(IsJaxOpNameAndType(kOpName, kOpType));
}
TEST(TfOpUtilsTest, JaxOpWithBracketTest) {
const absl::string_view kName = "op_name:op_type[array=([])]";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kJax);
EXPECT_EQ(tf_op.name, "op_name");
EXPECT_EQ(tf_op.type, "op_type");
EXPECT_EQ(TfOpEventName(kName), "op_type");
}
TEST(TfOpUtilsTest, JaxOpWithBracketAndTrailingColonTest) {
const absl::string_view kName = "op_name/op_type[array=([])]:";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kJax);
EXPECT_EQ(tf_op.name, "op_name/op_type[array=([])]");
EXPECT_EQ(tf_op.type, "op_type");
EXPECT_EQ(TfOpEventName(kName), "op_type");
}
TEST(TfOpUtilsTest, JaxOpNameWithMetadataTest) {
const absl::string_view kOpName =
"pmap(<unnamed wrapped function>)/gather[ "
"dimension_numbers=GatherDimensionNumbers(offset_dims=(2,), "
"collapsed_slice_dims=(0, 1), start_index_map=(0, 1))\n "
" slice_sizes=(1, 1, 81) ]:gather";
const absl::string_view kOpType = "gather";
EXPECT_TRUE(IsJaxOpNameAndType(kOpName, kOpType));
}
TEST(TfOpUtilsTest, OtherXlaOpTest) {
const absl::string_view kName =
"namescope.1/namespace__opname2d:namespace__opname2d";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kJax);
EXPECT_EQ(tf_op.name, "namescope.1/namespace__opname2d");
EXPECT_EQ(tf_op.type, "namespace__opname2d");
EXPECT_EQ(TfOpEventName(kName), "namespace__opname2d");
}
TEST(TfOpUtilsTest, OtherXlaOpNameTest) {
const absl::string_view kOpName = "namescope.1/namespace__opname2d";
const absl::string_view kOpType = "namespace__opname2d";
EXPECT_TRUE(IsJaxOpNameAndType(kOpName, kOpType));
}
TEST(TfOpUtilsTest, OpWithoutTypeTest) {
const absl::string_view kName = "namescope/OpName_1:";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kTensorFlow);
EXPECT_EQ(tf_op.name, "namescope/OpName_1");
EXPECT_EQ(tf_op.type, "OpName");
EXPECT_EQ(TfOpEventName(kName),
"OpName");
}
TEST(TfOpUtilsTest, OpTypeWithUnderstslTest) {
const absl::string_view kName = "namescope/OpName_a:";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kTensorFlow);
EXPECT_EQ(tf_op.name, "namescope/OpName_a");
EXPECT_EQ(tf_op.type, "OpName_a");
EXPECT_EQ(TfOpEventName(kName),
"OpName_a");
}
TEST(TfOpUtilsTest, NameScopeTest) {
const absl::string_view kName = "scope-1/scope2/OpName:OpType";
TfOp tf_op = ParseTfOpFullname(kName);
EXPECT_EQ(tf_op.category, Category::kTensorFlow);
EXPECT_EQ(tf_op.name, "scope-1/scope2/OpName");
EXPECT_EQ(tf_op.type, "OpType");
std::vector<absl::string_view> name_scopes = ParseTfNameScopes(tf_op);
EXPECT_EQ(name_scopes.size(), 2);
EXPECT_EQ(name_scopes[0], "scope-1");
EXPECT_EQ(name_scopes[1], "scope2");
}
}
}
} |
2,629 | cpp | google/tsl | buffer_pool | tsl/profiler/utils/buffer_pool.cc | tsl/profiler/utils/buffer_pool_test.cc | #ifndef TENSORFLOW_TSL_PROFILER_UTILS_BUFFER_POOL_H_
#define TENSORFLOW_TSL_PROFILER_UTILS_BUFFER_POOL_H_
#include <vector>
#include "tsl/platform/mutex.h"
#include "tsl/platform/thread_annotations.h"
namespace tsl {
namespace profiler {
class BufferPool {
public:
explicit BufferPool(size_t buffer_size_in_bytes);
~BufferPool();
uint8_t* GetOrCreateBuffer();
void ReclaimBuffer(uint8_t* buffer);
void DestroyAllBuffers();
size_t GetBufferSizeInBytes() const;
protected:
mutex buffers_mutex_;
std::vector<uint8_t*> buffers_ TF_GUARDED_BY(buffers_mutex_);
size_t buffer_size_in_bytes_;
};
}
}
#endif
#include "tsl/profiler/utils/buffer_pool.h"
#include <ios>
#include "tsl/platform/logging.h"
#include "tsl/platform/mem.h"
#include "tsl/platform/mutex.h"
namespace tsl {
namespace profiler {
BufferPool::BufferPool(size_t buffer_size_in_bytes)
: buffer_size_in_bytes_(buffer_size_in_bytes) {}
BufferPool::~BufferPool() { DestroyAllBuffers(); }
uint8_t* BufferPool::GetOrCreateBuffer() {
{
mutex_lock lock(buffers_mutex_);
if (!buffers_.empty()) {
uint8_t* buffer = buffers_.back();
buffers_.pop_back();
if (!buffer) {
LOG(ERROR) << "A reused buffer must not be null!";
return nullptr;
}
VLOG(3) << "Reused Buffer, buffer=" << std::hex
<< reinterpret_cast<uintptr_t>(buffer) << std::dec;
return buffer;
}
}
constexpr size_t kBufferAlignSize = 8;
uint8_t* buffer = reinterpret_cast<uint8_t*>(
port::AlignedMalloc(buffer_size_in_bytes_, kBufferAlignSize));
if (buffer == nullptr) {
LOG(WARNING) << "Buffer not allocated.";
return nullptr;
}
VLOG(3) << "Allocated Buffer, buffer=" << std::hex
<< reinterpret_cast<uintptr_t>(buffer) << std::dec
<< " size=" << buffer_size_in_bytes_;
return buffer;
}
void BufferPool::ReclaimBuffer(uint8_t* buffer) {
mutex_lock lock(buffers_mutex_);
buffers_.push_back(buffer);
VLOG(3) << "Reclaimed Buffer, buffer=" << std::hex
<< reinterpret_cast<uintptr_t>(buffer) << std::dec;
}
void BufferPool::DestroyAllBuffers() {
mutex_lock lock(buffers_mutex_);
for (uint8_t* buffer : buffers_) {
VLOG(3) << "Freeing Buffer, buffer:" << std::hex
<< reinterpret_cast<uintptr_t>(buffer) << std::dec;
port::AlignedFree(buffer);
}
buffers_.clear();
}
size_t BufferPool::GetBufferSizeInBytes() const {
return buffer_size_in_bytes_;
}
}
} | #include "tsl/profiler/utils/buffer_pool.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace profiler {
namespace {
TEST(BufferPoolTest, GetOrCreateBufferAlloc) {
constexpr size_t kBufferSizeInBytes = 32 * 1024;
BufferPool buffer_pool(kBufferSizeInBytes);
uint8_t* first_buffer = buffer_pool.GetOrCreateBuffer();
EXPECT_NE(first_buffer, nullptr);
uint8_t* second_buffer = buffer_pool.GetOrCreateBuffer();
EXPECT_NE(second_buffer, first_buffer);
for (size_t idx = 0; idx < kBufferSizeInBytes; ++idx) {
first_buffer[idx] = 0xAB;
}
buffer_pool.ReclaimBuffer(first_buffer);
buffer_pool.ReclaimBuffer(second_buffer);
}
TEST(BufferPoolTest, GetOrCreateBufferReuse) {
constexpr size_t kBufferSizeInBytes = 32 * 1024;
BufferPool buffer_pool(kBufferSizeInBytes);
uint8_t* buffer = buffer_pool.GetOrCreateBuffer();
EXPECT_NE(buffer, nullptr);
buffer[0] = 0xFF;
uint8_t* previous_buffer = buffer;
buffer_pool.ReclaimBuffer(buffer);
uint8_t* reused_buffer = buffer_pool.GetOrCreateBuffer();
EXPECT_EQ(reused_buffer, previous_buffer);
for (size_t idx = 0; idx < kBufferSizeInBytes; ++idx) {
reused_buffer[idx] = 0xCD;
}
buffer_pool.ReclaimBuffer(reused_buffer);
}
TEST(BufferPoolTest, DestroyAllBuffers) {
constexpr size_t kBufferSizeInBytes = 32 * 1024;
BufferPool buffer_pool(kBufferSizeInBytes);
uint8_t* first_buffer = buffer_pool.GetOrCreateBuffer();
EXPECT_NE(first_buffer, nullptr);
buffer_pool.DestroyAllBuffers();
for (size_t idx = 0; idx < kBufferSizeInBytes; ++idx) {
first_buffer[idx] = 0xEF;
}
uint8_t* second_buffer = buffer_pool.GetOrCreateBuffer();
for (size_t idx = 0; idx < kBufferSizeInBytes; ++idx) {
second_buffer[idx] = 0xAB;
}
buffer_pool.ReclaimBuffer(first_buffer);
buffer_pool.ReclaimBuffer(second_buffer);
}
}
}
} |
2,630 | cpp | google/tsl | group_events | tsl/profiler/utils/group_events.cc | tsl/profiler/utils/group_events_test.cc | #ifndef TENSORFLOW_TSL_PROFILER_UTILS_GROUP_EVENTS_H_
#define TENSORFLOW_TSL_PROFILER_UTILS_GROUP_EVENTS_H_
#include <deque>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>
#include "absl/container/flat_hash_map.h"
#include "absl/container/flat_hash_set.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "tsl/platform/logging.h"
#include "tsl/platform/types.h"
#include "tsl/profiler/protobuf/xplane.pb.h"
#include "tsl/profiler/utils/xplane_builder.h"
#include "tsl/profiler/utils/xplane_visitor.h"
namespace tsl {
namespace profiler {
struct InterThreadConnectInfo {
int64_t parent_event_type;
int64_t child_event_type;
std::vector<int64_t> parent_stat_types;
std::vector<int64_t> child_stat_types;
};
struct GroupMetadata {
std::string name;
absl::flat_hash_set<int64_t> parents;
absl::flat_hash_set<int64_t> children;
};
using GroupMetadataMap =
absl::flat_hash_map<int64_t , GroupMetadata>;
class EventNode {
public:
explicit EventNode(XEventVisitor visitor) : visitor_(std::move(visitor)) {}
EventNode(const EventNode& event_node) = delete;
EventNode& operator=(const EventNode&) = delete;
const std::vector<EventNode*>& GetParents() const { return parents_; }
const std::vector<EventNode*>& GetChildren() const { return children_; }
void AddChild(EventNode* child) {
children_.push_back(child);
child->parents_.push_back(this);
}
std::optional<int64_t> GetGroupId() const { return group_id_; }
std::string GetGroupName() const;
void SetGroupId(int64_t group_id);
void PropagateGroupId(int64_t group_id, GroupMetadataMap* group_metadata_map);
const XEventVisitor& GetEventVisitor() const { return visitor_; }
std::optional<XStatVisitor> GetContextStat(int64_t stat_type) const;
void AddStepName(absl::string_view step_name);
void SetIsEager(bool is_eager);
bool IsEager() const;
bool IsNestedIn(EventNode* parent);
const EventNode* FindParent(int64_t event_type) const;
void SetRootLevel(int root_level) { root_level_ = root_level; }
int RootLevel() const { return root_level_; }
bool IsCompiledFunc() const;
bool operator<(const EventNode& other) const {
return GetEventVisitor().TimestampPs() <
other.GetEventVisitor().TimestampPs();
}
private:
XStat* FindOrAddStatByType(int64_t stat_type);
XEventVisitor visitor_;
std::vector<EventNode*> parents_;
std::vector<EventNode*> children_;
std::optional<int64_t> group_id_;
int root_level_ = 0;
};
using EventNodeMap =
absl::flat_hash_map<int64_t , std::deque<EventNode>>;
using EventList = std::vector<EventNode*>;
struct ContextGroup {
std::vector<EventNode*> producers;
std::vector<EventNode*> consumers;
};
using ContextGroupMap = absl::flat_hash_map<
int ,
absl::flat_hash_map<uint64 , ContextGroup>>;
class EventForest {
public:
void AddSpace(
std::function<XPlaneVisitor(const tensorflow::profiler::XPlane*)>
visitor_factory,
tensorflow::profiler::XSpace* space);
void AddPlanes(
std::function<XPlaneVisitor(const tensorflow::profiler::XPlane*)>
visitor_factory,
const std::vector<tensorflow::profiler::XPlane*>& planes);
void ConnectEvents(
const std::vector<InterThreadConnectInfo>& connect_info_list = {});
void ConnectTfDataEvents();
void GroupEvents();
const EventNodeMap& GetEventNodeMap() const { return event_node_map_; }
const GroupMetadataMap& GetGroupMetadataMap() const {
return group_metadata_map_;
}
private:
void AddPlane(
std::function<XPlaneVisitor(const tensorflow::profiler::XPlane*)>
visitor_factory,
tensorflow::profiler::XPlane* plane);
void ConnectIntraThread(tensorflow::profiler::XPlane* plane,
XPlaneVisitor* visitor,
ContextGroupMap* context_groups);
void ConnectInterThread(
const std::vector<InterThreadConnectInfo>& connect_info_list);
void CreateEventGroups();
void MarkEagerlyExecutedGpuKernels();
void MarkEagerlyExecutedCpuTfOps();
void ProcessTfDataSteps();
void ProcessTensorFlowLoop();
void FindEventNodeAndApply(
int64_t event_type, const std::vector<int64_t>& stat_types,
const std::function<void(EventNode&, const std::vector<uint64>&)>& cb);
EventNodeMap event_node_map_;
std::vector<XPlaneVisitor> visitors_;
std::deque<std::pair<tensorflow::profiler::XPlane*, XPlaneVisitor>> planes_;
absl::flat_hash_set<int64_t> tf_data_step_ids_;
EventList tf_loop_root_events_;
GroupMetadataMap group_metadata_map_;
};
std::vector<InterThreadConnectInfo> CreateInterThreadConnectInfoList();
void GroupTfEvents(tensorflow::profiler::XSpace* space,
EventForest* event_forest);
void GroupTfEvents(tensorflow::profiler::XSpace* space);
bool CheckLoopOp(const tensorflow::profiler::XSpace& space);
void AddGroupMetadataToStepEvents(const GroupMetadataMap& group_metadata_map,
XLineBuilder& line);
void GroupHostAndPlanes(
tensorflow::profiler::XSpace* space,
const std::vector<tensorflow::profiler::XPlane*>& device_traces,
EventForest* event_forest);
void GroupXplaneEvents(tensorflow::profiler::XPlane* plane,
const GroupMetadataMap& group_metadata_map);
void GroupTpuEventsOSS(
tensorflow::profiler::XSpace* space,
const std::vector<tensorflow::profiler::XPlane*>& device_traces,
EventForest* event_forest);
}
}
#endif
#include "tsl/profiler/utils/group_events.h"
#include <algorithm>
#include <cstdint>
#include <functional>
#include <iterator>
#include <map>
#include <memory>
#include <optional>
#include <queue>
#include <string>
#include <utility>
#include <vector>
#include "absl/algorithm/container.h"
#include "absl/container/flat_hash_map.h"
#include "absl/functional/bind_front.h"
#include "absl/strings/str_cat.h"
#include "tsl/lib/gtl/map_util.h"
#include "tsl/platform/dso_loader.h"
#include "tsl/platform/env.h"
#include "tsl/platform/types.h"
#include "tsl/profiler/utils/tf_xplane_visitor.h"
#include "tsl/profiler/utils/xplane_builder.h"
#include "tsl/profiler/utils/xplane_schema.h"
#include "tsl/profiler/utils/xplane_utils.h"
#include "tsl/profiler/utils/xplane_visitor.h"
namespace tsl {
namespace profiler {
void CreateStatMetadata(XPlane* plane) {
XPlaneBuilder builder(plane);
builder.GetOrCreateStatMetadata(GetStatTypeStr(StatType::kGroupId));
builder.GetOrCreateStatMetadata(GetStatTypeStr(StatType::kStepName));
builder.GetOrCreateStatMetadata(GetStatTypeStr(StatType::kIsEager));
}
std::optional<int64_t> GetKernelEventType(bool is_host_plane,
const XEventVisitor& event) {
if (event.GetStat(StatType::kCorrelationId).has_value()) {
return is_host_plane ? HostEventType::kKernelLaunch
: HostEventType::kKernelExecute;
}
return std::nullopt;
}
int64_t GetEventType(bool is_host_plane, const XEventVisitor& event) {
if (std::optional<int64_t> event_type = event.Type()) {
return *event_type;
} else if (std::optional<int64_t> kernel_event_type =
GetKernelEventType(is_host_plane, event)) {
return *kernel_event_type;
} else {
return HostEventType::kUnknownHostEventType;
}
}
bool IsLegacyRootEvent(const XEventVisitor& event) {
return event.Type() == HostEventType::kTraceContext;
}
struct GroupingEventStats {
explicit GroupingEventStats(const XEventVisitor& event);
std::optional<int> producer_type;
std::optional<uint64_t> producer_id;
std::optional<int> consumer_type;
std::optional<uint64_t> consumer_id;
std::optional<int> root_level;
bool is_async = false;
};
GroupingEventStats::GroupingEventStats(const XEventVisitor& event) {
std::optional<int64_t> step_id;
event.ForEachStat([&](const XStatVisitor& stat) {
if (!stat.Type().has_value()) return;
switch (*stat.Type()) {
case StatType::kProducerType:
producer_type = stat.IntValue();
break;
case StatType::kProducerId:
producer_id = stat.IntOrUintValue();
break;
case StatType::kConsumerType:
consumer_type = stat.IntValue();
break;
case StatType::kConsumerId:
consumer_id = stat.IntOrUintValue();
break;
case StatType::kIsRoot:
root_level = stat.IntValue();
break;
case StatType::kIsAsync:
is_async = stat.BoolValue();
break;
case StatType::kStepId:
step_id = stat.IntValue();
break;
default:
break;
}
});
if (!root_level.has_value() && IsLegacyRootEvent(event)) {
root_level = 1;
}
}
void SetContextGroup(const GroupingEventStats& stats, EventNode* event,
ContextGroupMap* context_groups) {
if (stats.producer_type.has_value() && stats.producer_id.has_value()) {
((*context_groups)[*stats.producer_type][*stats.producer_id])
.producers.push_back(event);
}
if (stats.consumer_type.has_value() && stats.consumer_id.has_value()) {
((*context_groups)[*stats.consumer_type][*stats.consumer_id])
.consumers.push_back(event);
}
}
void ConnectContextGroups(const ContextGroupMap& context_groups) {
for (auto& type_id_group : context_groups) {
for (auto& id_group : type_id_group.second) {
const ContextGroup& group = id_group.second;
if (group.producers.size() >= 64 && group.consumers.size() >= 64) {
LOG_EVERY_N(WARNING, 1000)
<< "id:" << id_group.first
<< " producers:" << group.producers.size() << " : "
<< group.producers[0]->GetEventVisitor().Name()
<< " consumers:" << group.consumers.size() << " : "
<< group.consumers[0]->GetEventVisitor().Name();
continue;
}
for (EventNode* parent : group.producers) {
for (EventNode* child : group.consumers) {
parent->AddChild(child);
}
}
}
}
}
bool IsImplicitRootEvent(const XEventVisitor& event) {
static const auto* const kImplicitRootEvents =
new absl::flat_hash_set<int64_t>{
HostEventType::kFunctionRun, HostEventType::kSessionRun,
HostEventType::kRunGraph, HostEventType::kExecutorStateProcess};
return event.Type().has_value() &&
kImplicitRootEvents->contains(*event.Type());
}
void ProcessRootEvent(int64_t group_id, EventNode* root_event,
GroupMetadataMap* group_metadata_map) {
root_event->PropagateGroupId(group_id, group_metadata_map);
std::string group_name = root_event->GetGroupName();
if (!IsImplicitRootEvent(root_event->GetEventVisitor())) {
root_event->AddStepName(group_name);
}
(*group_metadata_map)[group_id].name = std::move(group_name);
}
using Comparator = std::function<bool(const EventNode*)>;
const EventNode* FindParentWithComparator(const Comparator& comparator,
const EventNode* node,
bool include_self) {
std::queue<const EventNode*> nodes;
absl::flat_hash_set<const EventNode*> seen = {node};
if (include_self) {
nodes.push(node);
} else {
for (const EventNode* parent : node->GetParents()) {
nodes.push(parent);
seen.insert(parent);
}
}
while (!nodes.empty()) {
const EventNode* node = nodes.front();
nodes.pop();
if (comparator(node)) return node;
for (const EventNode* parent : node->GetParents()) {
if (seen.contains(parent)) continue;
nodes.push(parent);
seen.insert(parent);
}
}
return nullptr;
}
bool IsIteratorEventType(std::optional<int64_t> event_type) {
return event_type == HostEventType::kIterator ||
event_type == HostEventType::kDeviceInputPipelineSecondIterator;
}
bool CheckLoopOp(const XSpace& space) {
for (const XPlane& plane : space.planes()) {
for (const auto& event_metadata : plane.event_metadata()) {
std::optional<int64_t> event_type =
FindHostEventType(event_metadata.second.name());
if (!event_type.has_value()) continue;
switch (*event_type) {
case HostEventType::kWhileOpEvalCond:
case HostEventType::kWhileOpStartBody:
case HostEventType::kForOp:
case HostEventType::kParallelForOp:
case HostEventType::kForeverOp:
return true;
default:
break;
}
}
}
return false;
}
std::optional<XStatVisitor> EventNode::GetContextStat(int64_t stat_type) const {
std::queue<const EventNode*> nodes;
absl::flat_hash_set<const EventNode*> seen = {this};
nodes.push(this);
while (!nodes.empty()) {
const EventNode* node = nodes.front();
nodes.pop();
if (std::optional<XStatVisitor> stat = node->visitor_.GetStat(stat_type)) {
return stat;
}
for (const EventNode* parent : node->GetParents()) {
if (seen.contains(parent)) continue;
nodes.push(parent);
seen.insert(parent);
}
}
return std::nullopt;
}
std::string EventNode::GetGroupName() const {
std::string name;
if (std::optional<XStatVisitor> stat = GetContextStat(StatType::kGraphType)) {
absl::StrAppend(&name, stat->StrOrRefValue(), " ");
} else if (!(IsImplicitRootEvent(visitor_))) {
absl::StrAppend(&name, GetEventVisitor().Name(), " ");
}
int64_t step_num = group_id_.value_or(0);
if (std::optional<XStatVisitor> stat = GetContextStat(StatType::kIterNum)) {
step_num = stat->IntValue();
} else if (std::optional<XStatVisitor> stat =
GetContextStat(StatType::kStepNum)) {
step_num = stat->IntValue();
}
absl::StrAppend(&name, step_num);
return name;
}
XStat* EventNode::FindOrAddStatByType(int64_t stat_type) {
const XPlaneVisitor& plane = visitor_.Plane();
const XStatMetadata* stat_metadata = plane.GetStatMetadataByType(stat_type);
DCHECK(stat_metadata != nullptr);
auto* raw_event = const_cast<XEvent*>(&visitor_.RawEvent());
return FindOrAddMutableStat(*stat_metadata, raw_event);
}
void EventNode::SetGroupId(int64_t group_id) {
group_id_ = group_id;
FindOrAddStatByType(StatType::kGroupId)->set_int64_value(group_id);
}
void EventNode::PropagateGroupId(int64_t group_id,
GroupMetadataMap* group_metadata_map) {
std::queue<EventNode*> nodes;
absl::flat_hash_set<EventNode*> seen = {this};
nodes.push(this);
while (!nodes.empty()) {
EventNode* node = nodes.front();
nodes.pop();
std::optional<int64_t> node_group_id = node->GetGroupId();
if (node_group_id.has_value()) {
if (*node_group_id != group_id) {
(*group_metadata_map)[group_id].children.insert(*node_group_id);
(*group_metadata_map)[*node_group_id].parents.insert(group_id);
}
} else {
node->SetGroupId(group_id);
for (EventNode* child : node->GetChildren()) {
if (seen.contains(child)) continue;
nodes.push(child);
seen.insert(child);
}
}
}
}
void EventNode::AddStepName(absl::string_view step_name) {
FindOrAddStatByType(StatType::kStepName)
->set_str_value(step_name.data(), step_name.size());
}
void EventNode::SetIsEager(bool is_eager) {
FindOrAddStatByType(StatType::kIsEager)->set_int64_value(is_eager ? 1 : 0);
}
bool EventNode::IsCompiledFunc() const {
auto is_func = visitor_.GetStat(StatType::kIsFunc);
return !is_func || is_func->IntValue();
}
bool EventNode::IsEager() const {
const EventNode* node = FindParent(HostEventType::kEagerKernelExecute);
if (node == nullptr) {
return false;
}
return !node->IsCompiledFunc();
}
const EventNode* EventNode::FindParent(int64_t event_type) const {
return FindParentWithComparator(
[event_type](const EventNode* node) {
return node->GetEventVisitor().Type() == event_type;
},
this, true);
}
void EventForest::FindEventNodeAndApply(
const int64_t event_type, const std::vector<int64_t>& stat_types,
const std::function<void(EventNode&, const std::vector<uint64>&)>& cb) {
if (auto* event_node_list = gtl::FindOrNull(event_node_map_, event_type)) {
for (EventNode& event_node : *event_node_list) {
std::vector<uint64> stats;
for (const auto stat_type : stat_types) {
std::optional<XStatVisitor> stat =
event_node.GetEventVisitor().GetStat(stat_type);
if (!stat) break;
stats.push_back(stat->IntOrUintValue());
}
if (stats.size() == stat_types.size()) {
cb(event_node, stats);
}
}
}
}
void EventForest::ConnectIntraThread(XPlane* plane, XPlaneVisitor* visitor,
ContextGroupMap* context_groups) {
bool is_host_plane = (visitor->Name() == kHostThreadsPlaneName);
for (auto& line : *plane->mutable_lines()) {
std::vector<EventNode*> parent_nodes;
for (auto& event : *line.mutable_events()) {
XEventVisitor event_visitor(visitor, &line, &event);
int64_t event_type = GetEventType(is_host_plane, event_visitor);
EventNode* cur_node =
&event_node_map_[event_type].emplace_back(std::move(event_visitor));
GroupingEventStats stats(cur_node->GetEventVisitor());
if (stats.root_level.has_value()) {
cur_node->SetRootLevel(*stats.root_level);
}
SetContextGroup(stats, cur_node, context_groups);
if (!stats.is_async) {
while (!parent_nodes.empty()) {
EventNode* parent_node = parent_nodes.back();
if (parent_node->GetEventVisitor().GetTimespan().Includes(
cur_node->GetEventVisitor().GetTimespan())) {
parent_node->AddChild(cur_node);
break;
} else {
parent_nodes.pop_back();
}
}
parent_nodes.push_back(cur_node);
}
}
}
}
void EventForest::ConnectInterThread(
const std::vector<InterThreadConnectInfo>& connect_info_list) {
for (const auto& connect_info : connect_info_list) {
absl::flat_hash_map<std::vector<uint64>, EventNode*> connect_map;
const std::vector<int64_t>& parent_stat_types =
connect_info.parent_stat_types;
const std::vector<int64_t>* child_stat_types =
&connect_info.child_stat_types;
if (child_stat_types->empty()) {
child_stat_types = &parent_stat_types;
}
FindEventNodeAndApply(connect_info.parent_event_type, parent_stat_types,
[&connect_map](EventNode& event_node,
const std::vector<uint64>& stats) {
connect_map[stats] = &event_node;
});
FindEventNodeAndApply(
connect_info.child_event_type, *child_stat_types,
[&connect_map](EventNode& event_node,
const std::vector<uint64>& stats) {
if (auto parent_event_node = gtl::FindPtrOrNull(connect_map, stats)) {
parent_event_node->AddChild(&event_node);
}
});
}
}
bool RootNeedsGrouping(const EventNode* root) {
if (root->GetGroupId().has_value()) return false;
const EventNode* root_parent = FindParentWithComparator(
[root](const EventNode* parent) {
return parent->RootLevel() == root->RootLevel();
},
root,
false);
return root_parent == nullptr;
}
void SortRootEventList(EventList* event_list) {
absl::c_sort(*event_list, [](const EventNode* e1, const EventNode* e2) {
return e1->RootLevel() == e2->RootLevel()
? *e1 < *e2
: e1->RootLevel() > e2->RootLevel();
});
}
void EventForest::CreateEventGroups() {
int64_t group_id = 0;
if (!tf_loop_root_events_.empty()) {
for (EventNode* root_event : tf_loop_root_events_) {
ProcessRootEvent(group_id++, root_event, &group_metadata_map_);
}
return;
}
EventList root_events;
for (auto& [event_type, events] : event_node_map_) {
for (EventNode& event : events) {
if (!event.RootLevel()) continue;
std::optional<XStatVisitor> step_id_stat =
event.GetEventVisitor().GetStat(StatType::kStepId);
if (step_id_stat && tf_data_step_ids_.contains(step_id_stat->IntValue()))
continue;
root_events.push_back(&event);
}
}
SortRootEventList(&root_events);
for (EventNode* root_event : root_events) {
if (RootNeedsGrouping(root_event)) {
ProcessRootEvent(group_id++, root_event, &group_metadata_map_);
}
}
}
void EventForest::MarkEagerlyExecutedGpuKernels() {
auto kernel_execute_event_node_list =
gtl::FindOrNull(event_node_map_, HostEventType::kKernelExecute);
if (!kernel_execute_event_node_list) return;
for (EventNode& kernel_execute_event_node : *kernel_execute_event_node_list) {
kernel_execute_event_node.SetIsEager(kernel_execute_event_node.IsEager());
}
}
void EventForest::MarkEagerlyExecutedCpuTfOps() {
auto tf_op_run_event_node_list =
gtl::FindOrNull(event_node_map_, HostEventType::kTfOpRun);
if (!tf_op_run_event_node_list) return;
for (EventNode& tf_op_run_event_node : *tf_op_run_event_node_list) {
tf_op_run_event_node.SetIsEager(tf_op_run_event_node.IsEager());
}
}
void EventForest::ProcessTfDataSteps() {
const int64_t tf_data_event_types[] = {
HostEventType::kTfDataCapturedFunctionRun,
HostEventType::kTfDataCapturedFunctionRunAsync,
HostEventType::kTfDataCapturedFunctionRunInstantiated,
HostEventType::kTfDataCapturedFunctionRunWithBorrowedArgs};
for (const int64_t tf_data_event_type : tf_data_event_types) {
auto tf_data_events = gtl::FindOrNull(event_node_map_, tf_data_event_type);
if (!tf_data_events) continue;
for (const EventNode& tf_data_event : *tf_data_events) {
std::optional<XStatVisitor> step_id_stat =
tf_data_event.GetEventVisitor().GetStat(StatType::kStepId);
if (!step_id_stat) continue;
tf_data_step_ids_.insert(step_id_stat->IntValue());
}
}
}
void EventForest::ProcessTensorFlowLoop() {
struct TensorFlowLoopIteration {
EventNode* first_event = nullptr;
std::vector<EventNode*> events;
};
using TensorFlowLoop =
absl::flat_hash_map<int64_t , TensorFlowLoopIteration>;
absl::flat_hash_map<int64_t , TensorFlowLoop> tf_loops;
auto executor_event_list =
gtl::FindOrNull(event_node_map_, HostEventType::kExecutorStateProcess);
if (!executor_event_list) return;
for (EventNode& executor_event : *executor_event_list) {
std::optional<XStatVisitor> step_id_stat =
executor_event.GetEventVisitor().GetStat(StatType::kStepId);
std::optional<XStatVisitor> iter_num_stat =
executor_event.GetEventVisitor().GetStat(StatType::kIterNum);
if (!step_id_stat || !iter_num_stat) continue;
int64_t step_id = step_id_stat->IntValue();
if (tf_data_step_ids_.contains(step_id)) continue;
TensorFlowLoop& tf_loop = tf_loops[step_id];
TensorFlowLoopIteration& iteration = tf_loop[iter_num_stat->IntValue()];
if (!iteration.first_event || executor_event < *iteration.first_event) {
iteration.first_event = &executor_event;
}
iteration.events.push_back(&executor_event);
}
std::vector<const TensorFlowLoopIteration*> iters;
for (const auto& step_id_and_tf_loop : tf_loops) {
const TensorFlowLoop& tf_loop = step_id_and_tf_loop.second;
if (tf_loop.size() == 1 && tf_loop.contains(0)) continue;
for (const auto& iter_num_and_iter : tf_loop) {
iters.push_back(&iter_num_and_iter.second);
}
}
absl::c_sort(iters, [](const auto& iter1, const auto& iter2) {
return *iter1->first_event < *iter2->first_event;
});
for (const TensorFlowLoopIteration* iter : iters) {
EventNode* root_event = iter->first_event;
tf_loop_root_events_.push_back(root_event);
for (EventNode* event : iter->events) {
if (event == root_event) continue;
root_event->AddChild(event);
}
}
}
void EventForest::AddPlane(
const std::function<XPlaneVisitor(const XPlane*)> visitor_factory,
XPlane* plane) {
CreateStatMetadata(plane);
planes_.push_back({plane, visitor_factory(plane)});
}
void EventForest::AddSpace(
const std::function<XPlaneVisitor(const XPlane*)> visitor_factory,
XSpace* space) {
for (XPlane& plane : *space->mutable_planes()) {
AddPlane(visitor_factory, &plane);
}
}
void EventForest::AddPlanes(
const std::function<XPlaneVisitor(const XPlane*)> visitor_factory,
const std::vector<XPlane*>& planes) {
for (XPlane* plane : planes) {
AddPlane(visitor_factory, plane);
}
}
void EventForest::ConnectEvents(
const std::vector<InterThreadConnectInfo>& connect_info_list) {
ContextGroupMap context_groups;
for (auto& plane_visitor : planes_) {
ConnectIntraThread(plane_visitor.first, &plane_visitor.second,
&context_groups);
}
ConnectInterThread(connect_info_list);
ConnectContextGroups(context_groups);
}
void EventForest::ConnectTfDataEvents() {
absl::flat_hash_map<
std::pair<int64_t , int64_t >,
std::vector<EventNode*>>
produce_iterator_map;
uint64 num_producers = 0;
for (HostEventType event_type :
{HostEventType::kPrefetchProduce,
HostEventType::kPar | #include "tsl/profiler/utils/group_events.h"
#include <optional>
#include "absl/container/flat_hash_map.h"
#include "absl/strings/string_view.h"
#include "tsl/platform/test.h"
#include "tsl/platform/types.h"
#include "tsl/profiler/protobuf/xplane.pb.h"
#include "tsl/profiler/utils/tf_xplane_visitor.h"
#include "tsl/profiler/utils/xplane_builder.h"
#include "tsl/profiler/utils/xplane_schema.h"
#include "tsl/profiler/utils/xplane_test_utils.h"
#include "tsl/profiler/utils/xplane_visitor.h"
namespace tsl {
namespace profiler {
namespace {
constexpr int64_t kTfExecutor = static_cast<int64_t>(ContextType::kTfExecutor);
TEST(GroupEventsTest, GroupGpuTraceLegacyRootTest) {
constexpr int64_t kStepNum = 123;
constexpr int64_t kStepId = 0;
constexpr int64_t kCorrelationId = 100;
XSpace space;
XPlaneBuilder host_plane_builder(GetOrCreateHostXPlane(&space));
host_plane_builder.ReserveLines(2);
auto main_thread = host_plane_builder.GetOrCreateLine(0);
CreateXEvent(
&host_plane_builder, &main_thread, HostEventType::kTraceContext, 0, 100,
{{StatType::kGraphType, "train"}, {StatType::kStepNum, kStepNum}});
CreateXEvent(&host_plane_builder, &main_thread, HostEventType::kFunctionRun,
10, 90,
{{StatType::kStepId, kStepId},
{StatType::kProducerType, kTfExecutor},
{StatType::kProducerId, kStepId}});
auto tf_executor_thread = host_plane_builder.GetOrCreateLine(1);
CreateXEvent(&host_plane_builder, &tf_executor_thread,
HostEventType::kExecutorStateProcess, 20, 80,
{{StatType::kStepId, kStepId},
{StatType::kConsumerType, kTfExecutor},
{StatType::kConsumerId, kStepId}});
CreateXEvent(&host_plane_builder, &tf_executor_thread, "matmul", 30, 70,
{{StatType::kCorrelationId, kCorrelationId}});
XPlane* device_plane = space.add_planes();
XPlaneBuilder device_plane_builder(device_plane);
device_plane_builder.ReserveLines(1);
auto stream = device_plane_builder.GetOrCreateLine(0);
CreateXEvent(&device_plane_builder, &stream, "matmul", 200, 300,
{{StatType::kCorrelationId, kCorrelationId}});
EventForest event_forest;
GroupTfEvents(&space, &event_forest);
const GroupMetadataMap& group_metadata_map =
event_forest.GetGroupMetadataMap();
XPlaneVisitor device_plane_visitor = CreateTfXPlaneVisitor(device_plane);
EXPECT_EQ(device_plane->lines(0).events(0).stats_size(), 3);
EXPECT_EQ(device_plane_visitor.GetStatType(
device_plane->lines(0).events(0).stats(1).metadata_id()),
StatType::kGroupId);
EXPECT_EQ(group_metadata_map.size(), 1);
EXPECT_EQ(group_metadata_map.at(0).name, "train 123");
}
TEST(GroupEventsTest, GroupGpuTraceTest) {
constexpr int64_t kStepNum = 123;
constexpr int64_t kStepId = 0;
constexpr int64_t kCorrelationId = 100;
XSpace space;
XPlaneBuilder host_plane_builder(GetOrCreateHostXPlane(&space));
host_plane_builder.ReserveLines(2);
auto main_thread = host_plane_builder.GetOrCreateLine(0);
CreateXEvent(
&host_plane_builder, &main_thread, "train", 0, 100,
{{StatType::kStepNum, kStepNum}, {StatType::kIsRoot, int64_t{1}}});
CreateXEvent(&host_plane_builder, &main_thread, HostEventType::kFunctionRun,
10, 90,
{{StatType::kStepId, kStepId},
{StatType::kProducerType, kTfExecutor},
{StatType::kProducerId, kStepId}});
auto tf_executor_thread = host_plane_builder.GetOrCreateLine(1);
CreateXEvent(&host_plane_builder, &tf_executor_thread,
HostEventType::kExecutorStateProcess, 20, 80,
{{StatType::kStepId, kStepId},
{StatType::kConsumerType, kTfExecutor},
{StatType::kConsumerId, kStepId}});
CreateXEvent(&host_plane_builder, &tf_executor_thread, "matmul", 30, 70,
{{StatType::kCorrelationId, kCorrelationId}});
XPlane* device_plane = space.add_planes();
XPlaneBuilder device_plane_builder(device_plane);
device_plane_builder.ReserveLines(1);
auto stream = device_plane_builder.GetOrCreateLine(0);
CreateXEvent(&device_plane_builder, &stream, "matmul", 200, 300,
{{StatType::kCorrelationId, kCorrelationId}});
EventForest event_forest;
GroupTfEvents(&space, &event_forest);
const GroupMetadataMap& group_metadata_map =
event_forest.GetGroupMetadataMap();
XPlaneVisitor device_plane_visitor = CreateTfXPlaneVisitor(device_plane);
EXPECT_EQ(device_plane->lines(0).events(0).stats_size(), 3);
EXPECT_EQ(device_plane_visitor.GetStatType(
device_plane->lines(0).events(0).stats(1).metadata_id()),
StatType::kGroupId);
EXPECT_EQ(group_metadata_map.size(), 1);
EXPECT_EQ(group_metadata_map.at(0).name, "train 123");
}
TEST(GroupEventsTest, GroupTensorFlowLoopTest) {
constexpr int64_t kStepId = 0;
constexpr int64_t kIterNum = 10;
constexpr int64_t kCorrelationId = 100;
XSpace space;
XPlaneBuilder host_plane_builder(GetOrCreateHostXPlane(&space));
host_plane_builder.ReserveLines(1);
auto tf_executor_thread = host_plane_builder.GetOrCreateLine(0);
CreateXEvent(&host_plane_builder, &tf_executor_thread,
HostEventType::kExecutorStateProcess, 5, 10,
{{StatType::kStepId, kStepId},
{StatType::kIterNum, kIterNum},
{StatType::kConsumerType, kTfExecutor},
{StatType::kConsumerId, kStepId}});
CreateXEvent(&host_plane_builder, &tf_executor_thread,
HostEventType::kExecutorStateProcess, 20, 80,
{{StatType::kStepId, kStepId},
{StatType::kIterNum, kIterNum},
{StatType::kConsumerType, kTfExecutor},
{StatType::kConsumerId, kStepId}});
CreateXEvent(&host_plane_builder, &tf_executor_thread, "matmul", 30, 70,
{{StatType::kCorrelationId, kCorrelationId}});
XPlane* device_plane = space.add_planes();
XPlaneBuilder device_plane_builder(device_plane);
device_plane_builder.ReserveLines(1);
auto stream = device_plane_builder.GetOrCreateLine(0);
CreateXEvent(&device_plane_builder, &stream, "matmul", 200, 300,
{{StatType::kCorrelationId, kCorrelationId}});
EventForest event_forest;
GroupTfEvents(&space, &event_forest);
const GroupMetadataMap& group_metadata_map =
event_forest.GetGroupMetadataMap();
XPlaneVisitor device_plane_visitor = CreateTfXPlaneVisitor(device_plane);
EXPECT_EQ(device_plane->lines(0).events(0).stats_size(), 3);
EXPECT_EQ(device_plane_visitor.GetStatType(
device_plane->lines(0).events(0).stats(1).metadata_id()),
StatType::kGroupId);
EXPECT_EQ(device_plane->lines(0).events(0).stats(1).int64_value(), 0);
EXPECT_EQ(group_metadata_map.size(), 1);
ASSERT_TRUE(group_metadata_map.contains(0));
EXPECT_EQ(group_metadata_map.at(0).name, "10");
}
TEST(GroupEventsTest, GroupMultipleTensorFlowLoopsTest) {
constexpr int64_t kFirstStepId = 0;
constexpr int64_t kSecondStepId = 1;
constexpr int64_t kFirstIterNumStart = 10;
constexpr int64_t kSecondIterNumStart = 0;
XSpace space;
XPlaneBuilder host_plane_builder(GetOrCreateHostXPlane(&space));
host_plane_builder.ReserveLines(2);
auto first_tf_executor_thread = host_plane_builder.GetOrCreateLine(0);
CreateXEvent(&host_plane_builder, &first_tf_executor_thread,
HostEventType::kExecutorStateProcess, 220, 80,
{{StatType::kStepId, kSecondStepId},
{StatType::kIterNum, kSecondIterNumStart},
{StatType::kConsumerType, kTfExecutor},
{StatType::kConsumerId, kSecondStepId}});
CreateXEvent(&host_plane_builder, &first_tf_executor_thread,
HostEventType::kExecutorStateProcess, 320, 80,
{{StatType::kStepId, kSecondStepId},
{StatType::kIterNum, kSecondIterNumStart + 1},
{StatType::kConsumerType, kTfExecutor},
{StatType::kConsumerId, kSecondStepId}});
auto second_tf_executor_thread = host_plane_builder.GetOrCreateLine(1);
CreateXEvent(&host_plane_builder, &second_tf_executor_thread,
HostEventType::kExecutorStateProcess, 20, 80,
{{StatType::kStepId, kFirstStepId},
{StatType::kIterNum, kFirstIterNumStart},
{StatType::kConsumerType, kTfExecutor},
{StatType::kConsumerId, kFirstStepId}});
CreateXEvent(&host_plane_builder, &second_tf_executor_thread,
HostEventType::kExecutorStateProcess, 120, 80,
{{StatType::kStepId, kFirstStepId},
{StatType::kIterNum, kFirstIterNumStart + 1},
{StatType::kConsumerType, kTfExecutor},
{StatType::kConsumerId, kFirstStepId}});
EventForest event_forest;
GroupTfEvents(&space, &event_forest);
const GroupMetadataMap& group_metadata_map =
event_forest.GetGroupMetadataMap();
EXPECT_EQ(group_metadata_map.size(), 4);
ASSERT_TRUE(group_metadata_map.contains(0));
EXPECT_EQ(group_metadata_map.at(0).name, "10");
ASSERT_TRUE(group_metadata_map.contains(1));
EXPECT_EQ(group_metadata_map.at(1).name, "11");
ASSERT_TRUE(group_metadata_map.contains(2));
EXPECT_EQ(group_metadata_map.at(2).name, "0");
ASSERT_TRUE(group_metadata_map.contains(3));
EXPECT_EQ(group_metadata_map.at(3).name, "1");
}
TEST(GroupEventsTest, EagerOpTest) {
XSpace space;
XPlane* host_plane = GetOrCreateHostXPlane(&space);
XPlaneBuilder host_plane_builder(host_plane);
host_plane_builder.ReserveLines(1);
auto main_thread = host_plane_builder.GetOrCreateLine(0);
XPlane* device_plane = space.add_planes();
XPlaneBuilder device_plane_builder(device_plane);
device_plane_builder.ReserveLines(1);
auto gpu_stream = device_plane_builder.GetOrCreateLine(0);
int64_t correlation_id = 100;
const char* kTF1GpuLaunchEvent = "tf1 matmul";
const char* kTF1GpuEvent = "tf1_kernel_matmul";
CreateXEvent(&host_plane_builder, &main_thread, kTF1GpuLaunchEvent, 10, 90,
{{StatType::kCorrelationId, correlation_id}});
CreateXEvent(&device_plane_builder, &gpu_stream, kTF1GpuEvent, 200, 300,
{{StatType::kCorrelationId, correlation_id}});
++correlation_id;
const char* kLegacyGpuLaunchEvent = "legacy matmul";
const char* kLegacyGpuEvent = "legacy_kernel_matmul";
CreateXEvent(&host_plane_builder, &main_thread,
HostEventType::kEagerKernelExecute, 100, 200);
CreateXEvent(&host_plane_builder, &main_thread, kLegacyGpuLaunchEvent, 110,
190, {{StatType::kCorrelationId, correlation_id}});
CreateXEvent(&device_plane_builder, &gpu_stream, kLegacyGpuEvent, 300, 400,
{{StatType::kCorrelationId, correlation_id}});
++correlation_id;
const char* kEagerOpGpuLaunchEvent = "eager op matmul";
const char* kEagerOpGpuEvent = "eager_op_kernel_matmul";
CreateXEvent(&host_plane_builder, &main_thread,
HostEventType::kEagerKernelExecute, 200, 300,
{{StatType::kIsFunc, static_cast<int64_t>(0)}});
CreateXEvent(&host_plane_builder, &main_thread, kEagerOpGpuLaunchEvent, 210,
290, {{StatType::kCorrelationId, correlation_id}});
CreateXEvent(&device_plane_builder, &gpu_stream, kEagerOpGpuEvent, 400, 500,
{{StatType::kCorrelationId, correlation_id}});
++correlation_id;
const char* kEagerFuncGpuLaunchEvent = "eager func matmul";
const char* kEagerFuncGpuEvent = "eager_func_kernel_matmul";
CreateXEvent(&host_plane_builder, &main_thread,
HostEventType::kEagerKernelExecute, 300, 400,
{{StatType::kIsFunc, static_cast<int64_t>(1)}});
CreateXEvent(&host_plane_builder, &main_thread, kEagerFuncGpuLaunchEvent, 310,
390, {{StatType::kCorrelationId, correlation_id}});
CreateXEvent(&device_plane_builder, &gpu_stream, kEagerFuncGpuEvent, 500, 600,
{{StatType::kCorrelationId, correlation_id}});
++correlation_id;
const char* kEagerOpCpuEvent = "eager_op_cpu_kernel:Matmul";
CreateXEvent(&host_plane_builder, &main_thread,
HostEventType::kEagerKernelExecute, 400, 500,
{{StatType::kIsFunc, static_cast<int64_t>(0)}});
CreateXEvent(&host_plane_builder, &main_thread, kEagerOpCpuEvent, 410, 490);
const char* kEagerFuncCpuEvent = "eager_func_cpu_kernel:Matmul";
CreateXEvent(&host_plane_builder, &main_thread,
HostEventType::kEagerKernelExecute, 500, 600,
{{StatType::kIsFunc, static_cast<int64_t>(1)}});
CreateXEvent(&host_plane_builder, &main_thread, kEagerFuncCpuEvent, 510, 590);
GroupTfEvents(&space);
auto is_eager = [](const XEventVisitor& event) {
auto eager_stats = event.GetStat(StatType::kIsEager);
return eager_stats && eager_stats->IntValue();
};
XPlaneVisitor host_plane_visitor = CreateTfXPlaneVisitor(host_plane);
int interested_events_encountered = 0;
host_plane_visitor.ForEachLine([&](const XLineVisitor& line) {
line.ForEachEvent([&](const XEventVisitor& event) {
if (event.Name() == kEagerOpCpuEvent) {
interested_events_encountered++;
EXPECT_TRUE(is_eager(event));
} else if (event.Name() == kEagerFuncCpuEvent) {
interested_events_encountered++;
EXPECT_FALSE(is_eager(event));
}
});
});
EXPECT_EQ(interested_events_encountered, 2);
XPlaneVisitor device_plane_visitor = CreateTfXPlaneVisitor(device_plane);
interested_events_encountered = 0;
device_plane_visitor.ForEachLine([&](const XLineVisitor& line) {
line.ForEachEvent([&](const XEventVisitor& event) {
if (event.Name() == kTF1GpuEvent) {
interested_events_encountered++;
EXPECT_FALSE(is_eager(event));
} else if (event.Name() == kLegacyGpuEvent) {
interested_events_encountered++;
EXPECT_FALSE(is_eager(event));
} else if (event.Name() == kEagerOpGpuEvent) {
interested_events_encountered++;
EXPECT_TRUE(is_eager(event));
} else if (event.Name() == kEagerFuncGpuEvent) {
interested_events_encountered++;
EXPECT_FALSE(is_eager(event));
}
});
});
EXPECT_EQ(interested_events_encountered, 4);
}
TEST(GroupEventsTest, FunctionOpTest) {
constexpr int64_t kStepNum = 123;
constexpr int64_t kStepId = 0;
constexpr int64_t kCorrelationId = 100;
XSpace space;
XPlane* host_plane = GetOrCreateHostXPlane(&space);
XPlaneBuilder host_plane_builder(host_plane);
host_plane_builder.ReserveLines(2);
auto main_thread = host_plane_builder.GetOrCreateLine(0);
CreateXEvent(&host_plane_builder, &main_thread, HostEventType::kTraceContext,
0, 100, {{StatType::kStepNum, kStepNum}});
CreateXEvent(&host_plane_builder, &main_thread,
HostEventType::kEagerKernelExecute, 10, 90);
CreateXEvent(&host_plane_builder, &main_thread, HostEventType::kFunctionRun,
10, 90,
{{StatType::kStepId, kStepId},
{StatType::kProducerType, kTfExecutor},
{StatType::kProducerId, kStepId}});
auto tf_executor_thread = host_plane_builder.GetOrCreateLine(1);
CreateXEvent(&host_plane_builder, &tf_executor_thread,
HostEventType::kExecutorStateProcess, 20, 80,
{{StatType::kStepId, kStepId},
{StatType::kConsumerType, kTfExecutor},
{StatType::kConsumerId, kStepId}});
CreateXEvent(&host_plane_builder, &tf_executor_thread, "matmul", 30, 30,
{{StatType::kCorrelationId, kCorrelationId}});
CreateXEvent(&host_plane_builder, &tf_executor_thread, "add:Add", 70, 20);
XPlane* device_plane = space.add_planes();
XPlaneBuilder device_plane_builder(device_plane);
device_plane_builder.ReserveLines(1);
auto stream = device_plane_builder.GetOrCreateLine(0);
CreateXEvent(&device_plane_builder, &stream, "matmul", 200, 300,
{{StatType::kCorrelationId, kCorrelationId}});
GroupTfEvents(&space);
XPlaneVisitor host_plane_visitor = CreateTfXPlaneVisitor(host_plane);
const XEvent& cpu_tf_op = host_plane->lines(1).events(2);
EXPECT_EQ(cpu_tf_op.stats_size(), 2);
EXPECT_EQ(host_plane_visitor.GetStatType(cpu_tf_op.stats(1).metadata_id()),
StatType::kIsEager);
EXPECT_EQ(cpu_tf_op.stats(1).int64_value(), 0);
XPlaneVisitor device_plane_visitor = CreateTfXPlaneVisitor(device_plane);
const XEvent& gpu_kernel = device_plane->lines(0).events(0);
EXPECT_EQ(gpu_kernel.stats_size(), 3);
EXPECT_EQ(device_plane_visitor.GetStatType(gpu_kernel.stats(2).metadata_id()),
StatType::kIsEager);
EXPECT_EQ(gpu_kernel.stats(2).int64_value(), 0);
}
TEST(GroupEventsTest, SemanticArgTest) {
constexpr int64_t kIsRoot = 1;
constexpr int64_t kStepNum = 100;
constexpr int64_t kContextType = 123;
constexpr uint64 kContextId = 456;
XSpace raw_space;
XPlane* raw_plane = raw_space.add_planes();
XPlaneBuilder plane(raw_plane);
plane.ReserveLines(2);
auto root_producer = plane.GetOrCreateLine(0);
CreateXEvent(&plane, &root_producer, HostEventType::kTraceContext, 0, 100,
{{StatType::kIsRoot, kIsRoot}, {StatType::kStepNum, kStepNum}});
CreateXEvent(&plane, &root_producer, HostEventType::kFunctionRun, 10, 90,
{{StatType::kProducerType, kContextType},
{StatType::kProducerId, kContextId}});
auto consumer = plane.GetOrCreateLine(1);
CreateXEvent(&plane, &consumer, HostEventType::kExecutorStateProcess, 20, 80,
{{StatType::kConsumerType, kContextType},
{StatType::kConsumerId, kContextId}});
GroupTfEvents(&raw_space);
int num_events = 0;
CreateTfXPlaneVisitor(raw_plane).ForEachLine([&](const XLineVisitor& line) {
num_events += line.NumEvents();
line.ForEachEvent([&](const XEventVisitor& event) {
std::optional<int64_t> group_id;
if (std::optional<XStatVisitor> stat =
event.GetStat(StatType::kGroupId)) {
group_id = stat->IntValue();
}
EXPECT_TRUE(group_id.has_value());
EXPECT_EQ(*group_id, 0);
});
});
EXPECT_EQ(num_events, 3);
}
TEST(GroupEventsTest, SemanticIntArgNoMatchTest) {
constexpr int64_t kIsRoot = 1;
constexpr int64_t kStepNum = 100;
constexpr int64_t kContextType = 123;
constexpr uint64 kProducerId = 456;
constexpr uint64 kConsumerId = 789;
XSpace raw_space;
XPlane* raw_plane = raw_space.add_planes();
XPlaneBuilder plane(raw_plane);
plane.ReserveLines(2);
auto root_producer = plane.GetOrCreateLine(0);
CreateXEvent(&plane, &root_producer, HostEventType::kTraceContext, 0, 100,
{{StatType::kIsRoot, kIsRoot}, {StatType::kStepNum, kStepNum}});
CreateXEvent(&plane, &root_producer, HostEventType::kFunctionRun, 10, 90,
{{StatType::kProducerType, kContextType},
{StatType::kProducerId, kProducerId}});
auto consumer = plane.GetOrCreateLine(1);
CreateXEvent(&plane, &consumer, HostEventType::kExecutorStateProcess, 20, 80,
{{StatType::kConsumerType, kContextType},
{StatType::kConsumerId, kConsumerId}});
GroupTfEvents(&raw_space);
int num_events = 0;
CreateTfXPlaneVisitor(raw_plane).ForEachLine([&](const XLineVisitor& line) {
num_events += line.NumEvents();
line.ForEachEvent([&](const XEventVisitor& event) {
std::optional<int64_t> group_id;
if (std::optional<XStatVisitor> stat =
event.GetStat(StatType::kGroupId)) {
group_id = stat->IntValue();
}
if (event.Type() == HostEventType::kExecutorStateProcess) {
EXPECT_FALSE(group_id.has_value());
} else {
EXPECT_TRUE(group_id.has_value());
EXPECT_EQ(*group_id, 0);
}
});
});
EXPECT_EQ(num_events, 3);
}
TEST(GroupEventsTest, SemanticUintArgNoMatchTest) {
constexpr int64_t kIsRoot = 1;
constexpr int64_t kStepNum = 100;
constexpr int64_t kContextType = 123;
constexpr uint64 kProducerId = UINT64_MAX;
constexpr uint64 kConsumerId = UINT64_MAX - 1;
XSpace raw_space;
XPlane* raw_plane = raw_space.add_planes();
XPlaneBuilder plane(raw_plane);
plane.ReserveLines(2);
auto root_producer = plane.GetOrCreateLine(0);
CreateXEvent(&plane, &root_producer, HostEventType::kTraceContext, 0, 100,
{{StatType::kIsRoot, kIsRoot}, {StatType::kStepNum, kStepNum}});
CreateXEvent(&plane, &root_producer, HostEventType::kFunctionRun, 10, 90,
{{StatType::kProducerType, kContextType},
{StatType::kProducerId, kProducerId}});
auto consumer = plane.GetOrCreateLine(1);
CreateXEvent(&plane, &consumer, HostEventType::kExecutorStateProcess, 20, 80,
{{StatType::kConsumerType, kContextType},
{StatType::kConsumerId, kConsumerId}});
GroupTfEvents(&raw_space);
int num_events = 0;
CreateTfXPlaneVisitor(raw_plane).ForEachLine([&](const XLineVisitor& line) {
num_events += line.NumEvents();
line.ForEachEvent([&](const XEventVisitor& event) {
std::optional<int64_t> group_id;
if (std::optional<XStatVisitor> stat =
event.GetStat(StatType::kGroupId)) {
group_id = stat->IntValue();
}
if (event.Type() == HostEventType::kExecutorStateProcess) {
EXPECT_FALSE(group_id.has_value());
} else {
EXPECT_TRUE(group_id.has_value());
EXPECT_EQ(*group_id, 0);
}
});
});
EXPECT_EQ(num_events, 3);
}
TEST(GroupEventsTest, AsyncEventTest) {
constexpr int64_t kIsRoot = 1;
constexpr int64_t kIsAsync = 1;
constexpr absl::string_view kParent = "parent";
constexpr absl::string_view kAsync = "async";
constexpr absl::string_view kChild = "child";
XSpace raw_space;
XPlane* raw_plane = raw_space.add_planes();
XPlaneBuilder plane(raw_plane);
plane.ReserveLines(1);
auto line = plane.GetOrCreateLine(0);
CreateXEvent(&plane, &line, kParent, 0, 100, {{StatType::kIsRoot, kIsRoot}});
CreateXEvent(&plane, &line, kAsync, 10, 200,
{{StatType::kIsAsync, kIsAsync}});
CreateXEvent(&plane, &line, kChild, 20, 80);
GroupTfEvents(&raw_space);
CreateTfXPlaneVisitor(raw_plane).ForEachLine([&](const XLineVisitor& line) {
EXPECT_EQ(line.NumEvents(), 3);
line.ForEachEvent([&](const XEventVisitor& event) {
std::optional<int64_t> group_id;
if (std::optional<XStatVisitor> stat =
event.GetStat(StatType::kGroupId)) {
group_id = stat->IntValue();
}
if (event.Name() == kAsync) {
EXPECT_FALSE(group_id.has_value());
} else {
EXPECT_TRUE(group_id.has_value());
EXPECT_EQ(*group_id, 0);
}
});
});
}
TEST(GroupEventsTest, BatchingSessionTest) {
constexpr absl::string_view kSchedule = "Schedule";
constexpr int64_t kBatchContextType =
static_cast<int64_t>(ContextType::kSharedBatchScheduler);
constexpr int64_t kBatchContextId = 123;
constexpr int64_t kBatchingSessionRunRootLevel = 1;
constexpr int64_t kProcessBatchRootLevel = 2;
XSpace raw_space;
XPlane* raw_plane = raw_space.add_planes();
XPlaneBuilder plane(raw_plane);
plane.ReserveLines(2);
auto request_thread = plane.GetOrCreateLine(0);
CreateXEvent(&plane, &request_thread, HostEventType::kBatchingSessionRun, 0,
100, {{StatType::kIsRoot, kBatchingSessionRunRootLevel}});
CreateXEvent(&plane, &request_thread, kSchedule, 0, 100,
{{StatType::kProducerType, kBatchContextType},
{StatType::kProducerId, kBatchContextId}});
CreateXEvent(&plane, &request_thread, HostEventType::kBatchingSessionRun, 200,
100, {{StatType::kIsRoot, kBatchingSessionRunRootLevel}});
CreateXEvent(&plane, &request_thread, kSchedule, 200, 100,
{{StatType::kProducerType, kBatchContextType},
{StatType::kProducerId, kBatchContextId}});
auto batch_thread = plane.GetOrCreateLine(1);
CreateXEvent(&plane, &batch_thread, HostEventType::kProcessBatch, 200, 100,
{{StatType::kConsumerType, kBatchContextType},
{StatType::kConsumerId, kBatchContextId},
{StatType::kIsRoot, kProcessBatchRootLevel}});
EventForest event_forest;
GroupTfEvents(&raw_space, &event_forest);
const GroupMetadataMap& group_metadata_map =
event_forest.GetGroupMetadataMap();
EXPECT_EQ(group_metadata_map.size(), 3);
EXPECT_EQ(group_metadata_map.at(0).parents.size(), 2);
EXPECT_EQ(group_metadata_map.at(1).children.size(), 1);
EXPECT_EQ(group_metadata_map.at(2).children.size(), 1);
uint64 num_checked = 0;
CreateTfXPlaneVisitor(raw_plane).ForEachLine([&](const XLineVisitor& line) {
line.ForEachEvent([&](const XEventVisitor& event) {
std::optional<int64_t> group_id;
if (std::optional<XStatVisitor> stat =
event.GetStat(StatType::kGroupId)) {
group_id = stat->IntValue();
}
EXPECT_TRUE(group_id.has_value());
if (line.Id() == 0 &&
event.Type() == HostEventType::kBatchingSessionRun) {
++num_checked;
} else if (line.Id() == 1 &&
event.Type() == HostEventType::kProcessBatch) {
++num_checked;
}
});
});
EXPECT_EQ(num_checked, 3);
}
TEST(GroupTPUEventsTest, TpuExecuteOpTest) {
tensorflow::profiler::XSpace space;
XPlaneBuilder host_plane_builder(GetOrCreateHostXPlane(&space));
host_plane_builder.ReserveLines(1);
auto main_thread = host_plane_builder.GetOrCreateLine(0);
CreateXEvent(
&host_plane_builder, &main_thread, HostEventType::kExecutorStateProcess,
20, 50,
{{StatType::kStepId, int64_t{123}}, {StatType::kIterNum, int64_t{456}}});
EventForest event_forest;
GroupTpuEventsOSS(&space, {}, &event_forest);
EXPECT_EQ(event_forest.GetGroupMetadataMap().size(), 1);
XPlaneVisitor host_plane_visitor = CreateTfXPlaneVisitor(&space.planes(0));
host_plane_visitor.ForEachLine([&](const XLineVisitor& line) {
line.ForEachEvent([&](const XEventVisitor& event) {
EXPECT_TRUE(event.GetStat(StatType::kGroupId).has_value());
});
});
}
TEST(GroupTPUEventsTest, TpuRequestTest) {
tensorflow::profiler::XSpace space;
XPlaneBuilder host_plane_builder(GetOrCreateHostXPlane(&space));
host_plane_builder.ReserveLines(1);
auto main_thread = host_plane_builder.GetOrCreateLine(0);
CreateXEvent(&host_plane_builder, &main_thread, HostEventType::kSessionRun, 0,
100, {{StatType::kIsRoot, int64_t{1}}});
CreateXEvent(&host_plane_builder, &main_thread,
GetHostEventTypeStr(HostEventType::kEnqueueRequestLocked), 20,
50,
{{StatType::kQueueAddr, int64_t{123}},
{StatType::kRequestId, int64_t{456}}});
EventForest event_forest;
GroupTpuEventsOSS(&space, {}, &event_forest);
EXPECT_EQ(event_forest.GetGroupMetadataMap().size(), 1);
XPlaneVisitor host_plane_visitor = CreateTfXPlaneVisitor(&space.planes(0));
host_plane_visitor.ForEachLine([&](const XLineVisitor& line) {
line.ForEachEvent([&](const XEventVisitor& event) {
EXPECT_TRUE(event.GetStat(StatType::kGroupId).has_value());
});
});
}
TEST(GroupTPUEventsTest, TpuProgramCallbackTest) {
tensorflow::profiler::XSpace space;
XPlaneBuilder host_plane_builder(GetOrCreateHostXPlane(&space));
host_plane_builder.ReserveLines(1);
auto main_thread = host_plane_builder.GetOrCreateLine(0);
CreateXEvent(&host_plane_builder, &main_thread, HostEventType::kSessionRun, 0,
100, {{StatType::kIsRoot, int64_t{1}}});
CreateXEvent(&host_plane_builder, &main_thread,
GetHostEventTypeStr(HostEventType::kDoEnqueueProgram), 20, 50,
{{StatType::kRunId, int64_t{123}},
{StatType::kQueueId, int64_t{0}},
{StatType::kDeviceOrdinal, int64_t{1}}});
EventForest event_forest;
GroupTpuEventsOSS(&space, {}, &event_forest);
EXPECT_EQ(event_forest.GetGroupMetadataMap().size(), 1);
XPlaneVisitor host_plane_visitor = CreateTfXPlaneVisitor(&space.planes(0));
host_plane_visitor.ForEachLine([&](const XLineVisitor& line) {
line.ForEachEvent([&](const XEventVisitor& event) {
EXPECT_TRUE(event.GetStat(StatType::kGroupId).has_value());
});
});
}
}
}
} |
2,631 | cpp | google/tsl | tpu_xplane_utils | tsl/profiler/utils/tpu_xplane_utils.cc | tsl/profiler/utils/tpu_xplane_utils_test.cc | #ifndef TENSORFLOW_TSL_PROFILER_UTILS_TPU_XPLANE_UTILS_H_
#define TENSORFLOW_TSL_PROFILER_UTILS_TPU_XPLANE_UTILS_H_
#include <optional>
#include <vector>
#include "absl/strings/string_view.h"
#include "tsl/profiler/protobuf/xplane.pb.h"
namespace tsl {
namespace profiler {
std::vector<const tensorflow::profiler::XPlane*> FindTensorCorePlanes(
const tensorflow::profiler::XSpace& xspace);
std::vector<tensorflow::profiler::XPlane*> FindMutableTensorCorePlanes(
tensorflow::profiler::XSpace* xspace);
std::optional<int> GetTensorCoreId(absl::string_view plane_name);
}
}
#endif
#include "tsl/profiler/utils/tpu_xplane_utils.h"
#include <optional>
#include <vector>
#include "tsl/platform/regexp.h"
#include "tsl/profiler/protobuf/xplane.pb.h"
#include "tsl/profiler/utils/xplane_schema.h"
#include "tsl/profiler/utils/xplane_utils.h"
namespace tsl {
namespace profiler {
std::vector<const XPlane*> FindTensorCorePlanes(const XSpace& xspace) {
return FindPlanes(xspace, [](const XPlane& xplane) {
static const LazyRE2 re = {kTpuPlaneRegex};
return RE2::FullMatch(xplane.name(), *re);
});
}
std::vector<XPlane*> FindMutableTensorCorePlanes(XSpace* xspace) {
return FindMutablePlanes(xspace, [](const XPlane& xplane) {
static const LazyRE2 re = {kTpuPlaneRegex};
return RE2::FullMatch(xplane.name(), *re);
});
}
std::optional<int> GetTensorCoreId(absl::string_view plane_name) {
int core_id = -1;
if (RE2::FullMatch(plane_name, {kTpuPlaneRegex}, &core_id)) {
return core_id;
}
return std::nullopt;
}
}
} | #include "tsl/profiler/utils/tpu_xplane_utils.h"
#include <vector>
#include "absl/strings/str_cat.h"
#include "tsl/platform/test.h"
#include "tsl/profiler/protobuf/xplane.pb.h"
#include "tsl/profiler/utils/xplane_schema.h"
#include "tsl/profiler/utils/xplane_utils.h"
namespace tsl {
namespace profiler {
namespace {
using ::testing::UnorderedElementsAre;
TEST(TpuXPlaneUtilsTest, GetTensorCoreXPlanesFromXSpace) {
XSpace xspace;
XPlane* p1 = FindOrAddMutablePlaneWithName(&xspace, TpuPlaneName(0));
XPlane* p2 = FindOrAddMutablePlaneWithName(&xspace, TpuPlaneName(1));
FindOrAddMutablePlaneWithName(&xspace, TpuPlaneName(2) + "Postfix");
std::vector<const XPlane*> xplanes = FindTensorCorePlanes(xspace);
EXPECT_THAT(xplanes, UnorderedElementsAre(p1, p2));
}
TEST(TpuXPlaneUtilsTest, GetMutableTensorCoreXPlanesFromXSpace) {
XSpace xspace;
XPlane* p1 = FindOrAddMutablePlaneWithName(&xspace, TpuPlaneName(0));
XPlane* p2 = FindOrAddMutablePlaneWithName(&xspace, TpuPlaneName(1));
FindOrAddMutablePlaneWithName(&xspace, TpuPlaneName(2) + "Postfix");
std::vector<XPlane*> xplanes = FindMutableTensorCorePlanes(&xspace);
EXPECT_THAT(xplanes, UnorderedElementsAre(p1, p2));
}
TEST(TpuXPlaneUtilsTest, GetTensorCoreIdFromPlaneName) {
EXPECT_EQ(GetTensorCoreId(TpuPlaneName(0)), 0);
}
TEST(TpuXPlaneUtilsTest, IsNotTensorCorePlaneName) {
EXPECT_FALSE(GetTensorCoreId("/metadata:0").has_value());
}
TEST(TpuXPlaneUtilsTest, IsNotTensorCorePlaneNameWithPrefix) {
EXPECT_FALSE(
GetTensorCoreId(absl::StrCat("/prefix", TpuPlaneName(0))).has_value());
}
}
}
} |
2,632 | cpp | google/tsl | xplane_to_trace_events | tsl/profiler/convert/xplane_to_trace_events.cc | tsl/profiler/convert/xplane_to_trace_events_test.cc | #ifndef TENSORFLOW_TSL_PROFILER_CONVERT_XPLANE_TO_TRACE_EVENTS_H_
#define TENSORFLOW_TSL_PROFILER_CONVERT_XPLANE_TO_TRACE_EVENTS_H_
#include <string>
#include "tsl/platform/types.h"
#include "tsl/profiler/convert/trace_container.h"
#include "tsl/profiler/protobuf/xplane.pb.h"
namespace tsl {
namespace profiler {
TraceContainer ConvertXSpaceToTraceContainer(
const tensorflow::profiler::XSpace& xspace);
void ConvertXSpaceToTraceEventsString(
const tensorflow::profiler::XSpace& xspace, std::string* content);
}
}
#endif
#include "tsl/profiler/convert/xplane_to_trace_events.h"
#include <stddef.h>
#include <algorithm>
#include <string>
#include <utility>
#include <vector>
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "tsl/platform/types.h"
#include "tsl/profiler/protobuf/trace_events.pb.h"
#include "tsl/profiler/protobuf/xplane.pb.h"
#include "tsl/profiler/utils/tf_xplane_visitor.h"
#include "tsl/profiler/utils/trace_utils.h"
#include "tsl/profiler/utils/xplane_schema.h"
#include "tsl/profiler/utils/xplane_utils.h"
#include "tsl/profiler/utils/xplane_visitor.h"
namespace tsl {
namespace profiler {
namespace {
using tensorflow::profiler::XSpace;
void BuildDeviceAndResources(uint32 device_id, const XPlaneVisitor& plane,
Device* device) {
device->set_name(std::string(plane.Name()));
device->set_device_id(device_id);
bool sort_by_ordinal = (device_id == kHostThreadsDeviceId);
int ordinal = 0;
plane.ForEachLine([&](const XLineVisitor& line) {
uint32 resource_id = line.DisplayId();
Resource& resource = (*device->mutable_resources())[resource_id];
resource.set_resource_id(resource_id);
resource.set_name(std::string(line.DisplayName()));
if (sort_by_ordinal) {
resource.set_sort_index(++ordinal);
}
});
}
void ConvertXPlaneToTraceEvents(uint32 device_id, const XPlaneVisitor& xplane,
TraceContainer& container) {
BuildDeviceAndResources(device_id, xplane,
container.MutableDevice(device_id));
xplane.ForEachLine([device_id, &container](const XLineVisitor& xline) {
uint32 resource_id = xline.DisplayId();
if (xline.DisplayName() == tsl::profiler::kXlaAsyncOpLineName) {
return;
}
xline.ForEachEvent(
[device_id, resource_id, &container](const XEventVisitor& xevent) {
int64_t event_type =
xevent.Type().value_or(HostEventType::kUnknownHostEventType);
if (IsInternalEvent(event_type)) return;
TraceEvent* event = container.CreateEvent();
auto& args = *event->mutable_args();
event->set_device_id(device_id);
event->set_resource_id(resource_id);
if (xevent.HasDisplayName()) {
event->set_name(std::string(xevent.DisplayName()));
args["long_name"] = std::string(xevent.Name());
} else {
event->set_name(std::string(xevent.Name()));
}
event->set_timestamp_ps(xevent.TimestampPs());
event->set_duration_ps(xevent.DurationPs());
auto for_each_stat = [&](const XStatVisitor& stat) {
if (stat.ValueCase() == XStat::VALUE_NOT_SET) return;
if (IsInternalStat(stat.Type())) return;
if (stat.Type() == StatType::kStepName) {
event->set_name(stat.ToString());
}
args[std::string(stat.Name())] = stat.ToString();
};
xevent.Metadata().ForEachStat(for_each_stat);
xevent.ForEachStat(for_each_stat);
});
});
}
}
uint64 GetTraceViewerMaxEvents() {
constexpr uint64 kMaxEvents = 1000000;
char* max_events = getenv("TF_PROFILER_TRACE_VIEWER_MAX_EVENTS");
if (max_events != nullptr) {
return std::stoull(max_events, nullptr, 10);
} else {
return kMaxEvents;
}
}
TraceContainer ConvertXSpaceToTraceContainer(const XSpace& xspace) {
TraceContainer container;
const XPlane* host_plane = FindPlaneWithName(xspace, kHostThreadsPlaneName);
if (host_plane != nullptr) {
XPlaneVisitor xplane = CreateTfXPlaneVisitor(host_plane);
ConvertXPlaneToTraceEvents(kHostThreadsDeviceId, xplane, container);
}
std::vector<const XPlane*> device_planes =
FindPlanesWithPrefix(xspace, kGpuPlanePrefix);
if (device_planes.empty()) {
device_planes = FindPlanesWithPrefix(xspace, kTpuPlanePrefix);
}
if (device_planes.empty()) {
device_planes = FindPlanesWithPrefix(xspace, kCustomPlanePrefix);
}
for (const XPlane* device_plane : device_planes) {
XPlaneVisitor xplane = CreateTfXPlaneVisitor(device_plane);
uint32 device_id = kFirstDeviceId + xplane.Id();
ConvertXPlaneToTraceEvents(device_id, xplane, container);
}
uint64 viewer_max_events = GetTraceViewerMaxEvents();
container.CapEvents(viewer_max_events);
return container;
}
void ConvertXSpaceToTraceEventsString(const XSpace& xspace,
std::string* content) {
ConvertXSpaceToTraceContainer(xspace).FlushAndSerializeEvents(content);
}
}
} | #include "tsl/profiler/convert/xplane_to_trace_events.h"
#include <limits>
#include <utility>
#include "tsl/platform/test.h"
#include "tsl/profiler/protobuf/trace_events.pb.h"
#include "tsl/profiler/protobuf/xplane.pb.h"
#include "tsl/profiler/utils/trace_utils.h"
#include "tsl/profiler/utils/xplane_builder.h"
#include "tsl/profiler/utils/xplane_schema.h"
namespace tsl {
namespace profiler {
namespace {
using tensorflow::profiler::XSpace;
void CreateXSpace(XSpace* space) {
XPlaneBuilder host_plane(space->add_planes());
host_plane.SetName(kHostThreadsPlaneName);
XLineBuilder thread1 = host_plane.GetOrCreateLine(10);
thread1.SetName("thread1");
XEventBuilder event1 =
thread1.AddEvent(*host_plane.GetOrCreateEventMetadata("event1"));
event1.SetTimestampNs(150000);
event1.SetDurationNs(10000);
event1.AddStatValue(*host_plane.GetOrCreateStatMetadata("tf_op"),
*host_plane.GetOrCreateStatMetadata("Relu"));
XLineBuilder thread2 = host_plane.GetOrCreateLine(20);
thread2.SetName("thread2");
XEventBuilder event2 =
thread2.AddEvent(*host_plane.GetOrCreateEventMetadata("event2"));
event2.SetTimestampNs(160000);
event2.SetDurationNs(10000);
event2.AddStatValue(*host_plane.GetOrCreateStatMetadata("tf_op"),
*host_plane.GetOrCreateStatMetadata("Conv2D"));
XPlaneBuilder device_plane(space->add_planes());
device_plane.SetName(GpuPlaneName(0));
device_plane.SetId(0);
XLineBuilder stream1 = device_plane.GetOrCreateLine(30);
stream1.SetName("gpu stream 1");
XEventBuilder event3 =
stream1.AddEvent(*device_plane.GetOrCreateEventMetadata("kernel1"));
event3.SetTimestampNs(180000);
event3.SetDurationNs(10000);
event3.AddStatValue(*device_plane.GetOrCreateStatMetadata("correlation id"),
55);
}
TEST(ConvertXPlaneToTraceEvents, Convert) {
XSpace xspace;
CreateXSpace(&xspace);
TraceContainer container = ConvertXSpaceToTraceContainer(xspace);
ASSERT_EQ(container.trace().devices_size(), 2);
EXPECT_EQ(
container.trace().devices().at(kHostThreadsDeviceId).resources_size(), 2);
EXPECT_EQ(container.trace().devices().at(kFirstDeviceId).resources_size(), 1);
EXPECT_EQ(container.UnsortedEvents().size(), 3);
}
TEST(ConvertXPlaneToTraceEvents, SkipAsyncOps) {
XSpace xspace;
XPlaneBuilder device_plane(xspace.add_planes());
device_plane.SetName(GpuPlaneName(0));
XLineBuilder async_ops = device_plane.GetOrCreateLine(10);
async_ops.SetName(kXlaAsyncOpLineName);
XEventBuilder event1 =
async_ops.AddEvent(*device_plane.GetOrCreateEventMetadata("event1"));
event1.SetTimestampNs(100);
event1.SetDurationNs(1);
TraceContainer container = ConvertXSpaceToTraceContainer(xspace);
ASSERT_THAT(container.UnsortedEvents(), ::testing::IsEmpty());
}
}
}
} |
2,633 | cpp | google/tsl | trace_container | tsl/profiler/convert/trace_container.cc | tsl/profiler/convert/trace_container_test.cc | #ifndef TENSORFLOW_TSL_PROFILER_CONVERT_TRACE_CONTAINER_H_
#define TENSORFLOW_TSL_PROFILER_CONVERT_TRACE_CONTAINER_H_
#include <string>
#include <string_view>
#include <vector>
#include "tsl/profiler/protobuf/trace_events.pb.h"
namespace tsl {
namespace profiler {
using tsl::profiler::Device;
using tsl::profiler::Trace;
using tsl::profiler::TraceEvent;
template <typename Event>
class AnyTraceContainer {
public:
virtual ~AnyTraceContainer() = default;
virtual TraceEvent* CreateEvent() = 0;
virtual const std::vector<TraceEvent*>& UnsortedEvents() const = 0;
};
class TraceContainer : public AnyTraceContainer<TraceEvent> {
public:
TraceContainer() = default;
~TraceContainer() final {
for (const TraceEvent* event : events_) {
delete event;
}
}
const Trace& trace() const { return metadata_; }
const std::vector<TraceEvent*>& UnsortedEvents() const final {
return events_;
}
void CapEvents(uint32_t max_count);
Device* MutableDevice(uint32_t device_id) {
return &(*metadata_.mutable_devices())[device_id];
}
TraceEvent* CreateEvent() final {
TraceEvent* event = new TraceEvent;
events_.push_back(event);
return event;
}
void FlushAndSerializeEvents(std::string* output);
bool ParseMetadataFromString(const std::string& description);
private:
Trace metadata_;
std::vector<TraceEvent*> events_;
};
}
}
#endif
#include "tsl/profiler/convert/trace_container.h"
#include <algorithm>
#include <string>
#include <string_view>
#include <vector>
#include "tsl/platform/protobuf.h"
namespace tsl {
namespace profiler {
bool TraceContainer::ParseMetadataFromString(const std::string& description) {
return protobuf::TextFormat::ParseFromString(description, &metadata_);
}
void TraceContainer::CapEvents(const uint32_t max_count) {
const size_t total_count = events_.size();
if (total_count <= max_count) {
return;
}
const std::vector<TraceEvent*>::iterator end = events_.begin() + max_count;
std::partial_sort(
events_.begin(), end, events_.end(),
[](const TraceEvent* const lhs, const TraceEvent* const rhs) -> bool {
return lhs->timestamp_ps() < rhs->timestamp_ps();
});
for (std::vector<TraceEvent*>::iterator i = end; i != events_.end(); ++i) {
delete *i;
}
events_.erase(end, events_.end());
}
void TraceContainer::FlushAndSerializeEvents(std::string* const output) {
Trace trace = metadata_;
for (TraceEvent* const event : events_) {
trace.mutable_trace_events()->AddAllocated(event);
}
events_.clear();
trace.SerializeToString(output);
}
}
} | #include "tsl/profiler/convert/trace_container.h"
#include <string>
#include "tsl/platform/protobuf.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace profiler {
namespace {
void PopulateDummyEvent(TraceEvent* const event) {
event->set_device_id(1);
event->set_resource_id(2);
event->set_name("A");
event->set_timestamp_ps(3);
event->set_duration_ps(4);
}
TEST(TraceContainer, TraceEventAllocation) {
TraceContainer container;
PopulateDummyEvent(container.CreateEvent());
}
TEST(TraceContainer, FlushAndSerializeEvents) {
TraceContainer container;
PopulateDummyEvent(container.CreateEvent());
EXPECT_EQ(container.UnsortedEvents().size(), 1);
std::string serialized;
container.FlushAndSerializeEvents(&serialized);
EXPECT_EQ(container.UnsortedEvents().size(), 0);
PopulateDummyEvent(container.CreateEvent());
EXPECT_EQ(container.UnsortedEvents().size(), 1);
std::string reserialized;
container.FlushAndSerializeEvents(&reserialized);
EXPECT_EQ(serialized, reserialized);
EXPECT_EQ(container.UnsortedEvents().size(), 0);
Trace trace;
trace.ParseFromString(reserialized);
EXPECT_EQ(trace.trace_events_size(), 1);
}
TEST(TraceContainer, CapEvents) {
TraceContainer container;
for (int i = 0; i < 100; i++) {
container.CreateEvent()->set_timestamp_ps((100 - i) % 50);
}
container.CapEvents(101);
EXPECT_EQ(container.UnsortedEvents().size(), 100);
container.CapEvents(100);
EXPECT_EQ(container.UnsortedEvents().size(), 100);
container.CapEvents(99);
EXPECT_EQ(container.UnsortedEvents().size(), 99);
container.CapEvents(50);
EXPECT_EQ(container.UnsortedEvents().size(), 50);
for (const TraceEvent* const event : container.UnsortedEvents()) {
EXPECT_LT(event->timestamp_ps(), 25);
}
}
}
}
} |
2,634 | cpp | google/tsl | trace_events_to_json | tsl/profiler/convert/trace_events_to_json.cc | tsl/profiler/convert/trace_events_to_json_test.cc | #ifndef TENSORFLOW_TSL_PROFILER_CONVERT_TRACE_EVENTS_TO_JSON_H_
#define TENSORFLOW_TSL_PROFILER_CONVERT_TRACE_EVENTS_TO_JSON_H_
#include <string>
#include "tsl/platform/types.h"
#include "tsl/profiler/convert/trace_container.h"
namespace tsl {
namespace profiler {
std::string TraceContainerToJson(const TraceContainer& container);
}
}
#endif
#include "tsl/profiler/convert/trace_events_to_json.h"
#include <algorithm>
#include <string>
#include <utility>
#include "absl/algorithm/container.h"
#include "absl/strings/str_cat.h"
#include "json/json.h"
#include "tsl/platform/protobuf.h"
#include "tsl/platform/types.h"
#include "tsl/profiler/protobuf/trace_events.pb.h"
#include "tsl/profiler/utils/format_utils.h"
#include "tsl/profiler/utils/math_utils.h"
namespace tsl {
namespace profiler {
namespace {
inline std::string PicosToMicrosString(uint64 ps) {
return MaxPrecision(PicoToMicro(ps));
}
inline std::string JsonString(const std::string& s) {
return Json::valueToQuotedString(s.c_str());
}
template <typename Map>
std::vector<const typename Map::value_type*> SortByKey(const Map& m) {
std::vector<const typename Map::value_type*> pairs;
pairs.reserve(m.size());
for (const auto& pair : m) {
pairs.push_back(&pair);
}
absl::c_sort(pairs, [](const typename Map::value_type* a,
const typename Map::value_type* b) {
return a->first < b->first;
});
return pairs;
}
inline void AddDeviceMetadata(uint32 device_id, const Device& device,
std::string* json) {
if (!device.name().empty()) {
absl::StrAppend(json, R"({"ph":"M","pid":)", device_id,
R"(,"name":"process_name","args":{"name":)",
JsonString(device.name()), "}},");
}
absl::StrAppend(json, R"({"ph":"M","pid":)", device_id,
R"(,"name":"process_sort_index","args":{"sort_index":)",
device_id, "}},");
}
inline void AddResourceMetadata(uint32 device_id, uint32 resource_id,
const Resource& resource, std::string* json) {
if (!resource.name().empty()) {
absl::StrAppend(json, R"({"ph":"M","pid":)", device_id, R"(,"tid":)",
resource_id, R"(,"name":"thread_name","args":{"name":)",
JsonString(resource.name()), "}},");
}
uint32 sort_index =
resource.sort_index() ? resource.sort_index() : resource_id;
absl::StrAppend(json, R"({"ph":"M","pid":)", device_id, R"(,"tid":)",
resource_id, R"(,"name":"thread_sort_index")",
R"(,"args":{"sort_index":)", sort_index, "}},");
}
inline void AddTraceEvent(const TraceEvent& event, string* json) {
auto duration_ps = std::max(event.duration_ps(), protobuf_uint64{1});
absl::StrAppend(json, R"({"ph":"X","pid":)", event.device_id(), R"(,"tid":)",
event.resource_id(), R"(,"ts":)",
PicosToMicrosString(event.timestamp_ps()), R"(,"dur":)",
PicosToMicrosString(duration_ps), R"(,"name":)",
JsonString(event.name()));
if (!event.args().empty()) {
absl::StrAppend(json, R"(,"args":{)");
for (const auto* arg : SortByKey(event.args())) {
absl::StrAppend(json, JsonString(arg->first), ":",
JsonString(arg->second), ",");
}
json->back() = '}';
}
absl::StrAppend(json, "},");
}
}
std::string TraceContainerToJson(const TraceContainer& container) {
std::string json =
R"({"displayTimeUnit":"ns","metadata":{"highres-ticks":true},)"
R"("traceEvents":[)";
for (const auto* id_and_device : SortByKey(container.trace().devices())) {
uint32 device_id = id_and_device->first;
const Device& device = id_and_device->second;
AddDeviceMetadata(device_id, device, &json);
for (const auto* id_and_resource : SortByKey(device.resources())) {
uint32 resource_id = id_and_resource->first;
const Resource& resource = id_and_resource->second;
AddResourceMetadata(device_id, resource_id, resource, &json);
}
}
for (const TraceEvent* const event : container.UnsortedEvents()) {
AddTraceEvent(*event, &json);
}
absl::StrAppend(&json, "{}]}");
return json;
}
}
} | #include "tsl/profiler/convert/trace_events_to_json.h"
#include <string>
#include "json/json.h"
#include "tsl/platform/protobuf.h"
#include "tsl/platform/test.h"
#include "tsl/profiler/convert/trace_container.h"
#include "tsl/profiler/protobuf/trace_events.pb.h"
namespace tsl {
namespace profiler {
namespace {
Json::Value ToJsonValue(const std::string& json_str) {
Json::Value json;
Json::Reader reader;
EXPECT_TRUE(reader.parse(json_str, json));
return json;
}
TEST(TraceEventsToJson, JsonConversion) {
const std::string metadata_string = R"pb(
devices {
key: 2
value {
name: 'D2'
device_id: 2
resources {
key: 2
value { resource_id: 2 name: 'R2.2' }
}
}
}
devices {
key: 1
value {
name: 'D1'
device_id: 1
resources {
key: 2
value { resource_id: 1 name: 'R1.2' }
}
}
}
)pb";
TraceContainer container;
EXPECT_TRUE(container.ParseMetadataFromString(metadata_string));
TraceEvent* event = container.CreateEvent();
event->set_device_id(1);
event->set_resource_id(2);
event->set_name("E1.2.1");
event->set_timestamp_ps(100000);
event->set_duration_ps(10000);
event->mutable_args()->insert({"long_name", "E1.2.1 long"});
event->mutable_args()->insert({"arg2", "arg2 val"});
event = container.CreateEvent();
event->set_device_id(2);
event->set_resource_id(2);
event->set_name("E2.2.1 # \"comment\"");
event->set_timestamp_ps(105000);
container.CapEvents(2);
Json::Value json = ToJsonValue(TraceContainerToJson(container));
Json::Value expected_json = ToJsonValue(R"(
{
"displayTimeUnit": "ns",
"metadata": { "highres-ticks": true },
"traceEvents": [
{"ph":"M", "pid":1, "name":"process_name", "args":{"name":"D1"}},
{"ph":"M", "pid":1, "name":"process_sort_index", "args":{"sort_index":1}},
{"ph":"M", "pid":1, "tid":2, "name":"thread_name",
"args":{"name":"R1.2"}},
{"ph":"M", "pid":1, "tid":2, "name":"thread_sort_index",
"args":{"sort_index":2}},
{"ph":"M", "pid":2, "name":"process_name", "args":{"name":"D2"}},
{"ph":"M", "pid":2, "name":"process_sort_index", "args":{"sort_index":2}},
{"ph":"M", "pid":2, "tid":2, "name":"thread_name",
"args":{"name":"R2.2"}},
{"ph":"M", "pid":2, "tid":2, "name":"thread_sort_index",
"args":{"sort_index":2}},
{
"ph" : "X",
"pid" : 1,
"tid" : 2,
"name" : "E1.2.1",
"ts" : 0.1,
"dur" : 0.01,
"args" : {"arg2": "arg2 val", "long_name": "E1.2.1 long"}
},
{
"ph" : "X",
"pid" : 2,
"tid" : 2,
"name" : "E2.2.1 # \"comment\"",
"ts" : 0.105,
"dur" : 1e-6
},
{}
]
})");
EXPECT_EQ(json, expected_json);
}
}
}
} |
2,635 | cpp | google/tsl | remote_profiler_session_manager | tsl/profiler/rpc/client/remote_profiler_session_manager.cc | tsl/profiler/rpc/client/remote_profiler_session_manager_test.cc | #ifndef TENSORFLOW_TSL_PROFILER_RPC_CLIENT_REMOTE_PROFILER_SESSION_MANAGER_H_
#define TENSORFLOW_TSL_PROFILER_RPC_CLIENT_REMOTE_PROFILER_SESSION_MANAGER_H_
#include <functional>
#include <memory>
#include <vector>
#include "absl/strings/string_view.h"
#include "tsl/platform/macros.h"
#include "tsl/platform/mutex.h"
#include "tsl/platform/status.h"
#include "tsl/platform/thread_annotations.h"
#include "tsl/platform/types.h"
#include "tsl/profiler/rpc/client/profiler_client.h"
namespace tsl {
namespace profiler {
using AddressResolver = std::function<std::string(absl::string_view)>;
class RemoteProfilerSessionManager {
public:
struct Response {
std::string service_address;
std::unique_ptr<tensorflow::ProfileResponse> profile_response;
absl::Status status;
};
static std::unique_ptr<RemoteProfilerSessionManager> Create(
const tensorflow::RemoteProfilerSessionManagerOptions& options,
const tensorflow::ProfileRequest& request, absl::Status& out_status,
AddressResolver resolver = nullptr);
std::vector<Response> WaitForCompletion();
RemoteProfilerSessionManager(const RemoteProfilerSessionManager&) = delete;
RemoteProfilerSessionManager& operator=(const RemoteProfilerSessionManager&) =
delete;
~RemoteProfilerSessionManager();
private:
explicit RemoteProfilerSessionManager(
tensorflow::RemoteProfilerSessionManagerOptions options,
tensorflow::ProfileRequest request, AddressResolver resolver);
absl::Status Init();
mutex mutex_;
tensorflow::RemoteProfilerSessionManagerOptions options_
TF_GUARDED_BY(mutex_);
tensorflow::ProfileRequest request_ TF_GUARDED_BY(mutex_);
std::vector<std::unique_ptr<RemoteProfilerSession>> clients_
TF_GUARDED_BY(mutex_);
AddressResolver resolver_ TF_GUARDED_BY(mutex_);
};
}
}
#endif
#include "tsl/profiler/rpc/client/remote_profiler_session_manager.h"
#include <cstddef>
#include <memory>
#include "absl/memory/memory.h"
#include "absl/strings/string_view.h"
#include "absl/time/clock.h"
#include "absl/time/time.h"
#include "tsl/platform/env_time.h"
#include "tsl/platform/errors.h"
#include "tsl/platform/logging.h"
#include "tsl/platform/types.h"
#include "tsl/profiler/rpc/client/profiler_client.h"
#include "tsl/profiler/utils/time_utils.h"
namespace tsl {
namespace profiler {
using tensorflow::ProfileRequest;
using tensorflow::RemoteProfilerSessionManagerOptions;
std::unique_ptr<RemoteProfilerSessionManager>
RemoteProfilerSessionManager::Create(
const RemoteProfilerSessionManagerOptions& options,
const ProfileRequest& request, absl::Status& out_status,
AddressResolver resolver) {
VLOG(1) << "Creating a RemoteProfilerSessionManager.";
auto session_manager = absl::WrapUnique(
new RemoteProfilerSessionManager(options, request, resolver));
out_status = session_manager->Init();
if (!out_status.ok()) {
return nullptr;
}
return session_manager;
}
RemoteProfilerSessionManager::RemoteProfilerSessionManager(
RemoteProfilerSessionManagerOptions options, ProfileRequest request,
AddressResolver resolver)
: options_(options), request_(request) {
if (resolver) {
resolver_ = resolver;
} else {
resolver_ = [](absl::string_view addr) { return std::string(addr); };
}
}
RemoteProfilerSessionManager::~RemoteProfilerSessionManager() {
VLOG(2) << "Destroying RemoteProfilerSessionManager.";
}
absl::Status RemoteProfilerSessionManager::Init() {
mutex_lock lock(mutex_);
VLOG(1) << "SessionManager initializing.";
const absl::Time session_created_ts =
absl::FromUnixNanos(options_.session_creation_timestamp_ns());
const absl::Time deadline =
session_created_ts +
absl::Milliseconds(options_.max_session_duration_ms());
LOG(INFO) << "Deadline set to " << deadline
<< " because max_session_duration_ms was "
<< options_.max_session_duration_ms()
<< " and session_creation_timestamp_ns was "
<< options_.session_creation_timestamp_ns() << " ["
<< session_created_ts << "]";
clients_.reserve(options_.service_addresses_size());
ProfileRequest request = request_;
for (auto& service_address : options_.service_addresses()) {
std::string resolved_service_address = resolver_(service_address);
request.set_host_name(resolved_service_address);
auto client = RemoteProfilerSession::Create(resolved_service_address,
deadline, request);
clients_.push_back(std::move(client));
}
LOG(INFO) << "Issued Profile gRPC to " << clients_.size() << " clients";
return absl::OkStatus();
}
std::vector<RemoteProfilerSessionManager::Response>
RemoteProfilerSessionManager::WaitForCompletion() {
mutex_lock lock(mutex_);
std::vector<RemoteProfilerSessionManager::Response> remote_responses(
clients_.size());
for (int32_t idx = 0; idx < clients_.size(); ++idx) {
auto& remote_response = remote_responses[idx];
auto* client = clients_[idx].get();
remote_response.profile_response =
client->WaitForCompletion(remote_response.status);
remote_response.service_address = std::string(client->GetServiceAddress());
}
return remote_responses;
}
}
} | #include "tsl/profiler/rpc/client/remote_profiler_session_manager.h"
#include <memory>
#include <string>
#include <vector>
#include "absl/status/status.h"
#include "absl/time/clock.h"
#include "absl/time/time.h"
#include "tsl/platform/errors.h"
#include "tsl/platform/status.h"
#include "tsl/platform/test.h"
#include "tsl/platform/types.h"
#include "tsl/profiler/protobuf/profiler_options.pb.h"
#include "tsl/profiler/protobuf/profiler_service.pb.h"
#include "tsl/profiler/rpc/client/profiler_client_test_util.h"
namespace tsl {
namespace profiler {
namespace {
using tensorflow::ProfileRequest;
using tensorflow::RemoteProfilerSessionManagerOptions;
using ::tsl::profiler::test::DurationApproxLess;
using ::tsl::profiler::test::DurationNear;
using ::tsl::profiler::test::StartServer;
using ::tsl::testing::TmpDir;
using Response = tsl::profiler::RemoteProfilerSessionManager::Response;
constexpr double kGracePeriodSeconds = 10.0;
ProfileRequest PopulateProfileRequest(
absl::string_view repository_root, absl::string_view session_id,
absl::string_view host_name,
const RemoteProfilerSessionManagerOptions& options) {
constexpr uint64 kMaxEvents = 1000000;
const absl::string_view kXPlanePb = "xplane.pb";
ProfileRequest request;
request.set_duration_ms(options.profiler_options().duration_ms());
request.set_max_events(kMaxEvents);
request.set_repository_root(repository_root.data(), repository_root.size());
request.set_session_id(session_id.data(), session_id.size());
request.set_host_name(host_name.data(), host_name.size());
request.add_tools(kXPlanePb.data(), kXPlanePb.size());
*request.mutable_opts() = options.profiler_options();
return request;
}
TEST(RemoteProfilerSessionManagerTest, Simple) {
absl::Duration duration = absl::Milliseconds(30);
RemoteProfilerSessionManagerOptions options;
*options.mutable_profiler_options() = tsl::ProfilerSession::DefaultOptions();
options.mutable_profiler_options()->set_duration_ms(
absl::ToInt64Milliseconds(duration));
std::string service_address;
auto server = StartServer(duration, &service_address);
options.add_service_addresses(service_address);
absl::Time approx_start = absl::Now();
absl::Duration grace = absl::Seconds(kGracePeriodSeconds);
absl::Duration max_duration = duration + grace;
options.set_max_session_duration_ms(absl::ToInt64Milliseconds(max_duration));
options.set_session_creation_timestamp_ns(absl::ToUnixNanos(approx_start));
ProfileRequest request =
PopulateProfileRequest(TmpDir(), "session_id", service_address, options);
absl::Status status;
auto sessions =
RemoteProfilerSessionManager::Create(options, request, status);
EXPECT_TRUE(status.ok());
std::vector<Response> responses = sessions->WaitForCompletion();
absl::Duration elapsed = absl::Now() - approx_start;
ASSERT_EQ(responses.size(), 1);
EXPECT_TRUE(responses.back().status.ok());
EXPECT_TRUE(responses.back().profile_response->empty_trace());
EXPECT_EQ(responses.back().profile_response->tool_data_size(), 0);
EXPECT_THAT(elapsed, DurationApproxLess(max_duration));
}
TEST(RemoteProfilerSessionManagerTest, ExpiredDeadline) {
absl::Duration duration = absl::Milliseconds(30);
RemoteProfilerSessionManagerOptions options;
*options.mutable_profiler_options() = tsl::ProfilerSession::DefaultOptions();
options.mutable_profiler_options()->set_duration_ms(
absl::ToInt64Milliseconds(duration));
std::string service_address;
auto server = StartServer(duration, &service_address);
options.add_service_addresses(service_address);
absl::Duration grace = absl::Seconds(kGracePeriodSeconds);
absl::Duration max_duration = duration + grace;
options.set_max_session_duration_ms(absl::ToInt64Milliseconds(max_duration));
options.set_session_creation_timestamp_ns(0);
absl::Time approx_start = absl::Now();
ProfileRequest request =
PopulateProfileRequest(TmpDir(), "session_id", service_address, options);
absl::Status status;
auto sessions =
RemoteProfilerSessionManager::Create(options, request, status);
EXPECT_TRUE(status.ok());
std::vector<Response> responses = sessions->WaitForCompletion();
absl::Duration elapsed = absl::Now() - approx_start;
EXPECT_THAT(elapsed, DurationNear(absl::Seconds(0)));
ASSERT_EQ(responses.size(), 1);
EXPECT_TRUE(absl::IsDeadlineExceeded(responses.back().status));
EXPECT_TRUE(responses.back().profile_response->empty_trace());
EXPECT_EQ(responses.back().profile_response->tool_data_size(), 0);
}
TEST(RemoteProfilerSessionManagerTest, LongSession) {
absl::Duration duration = absl::Seconds(3);
RemoteProfilerSessionManagerOptions options;
*options.mutable_profiler_options() = tsl::ProfilerSession::DefaultOptions();
options.mutable_profiler_options()->set_duration_ms(
absl::ToInt64Milliseconds(duration));
std::string service_address;
auto server = StartServer(duration, &service_address);
options.add_service_addresses(service_address);
absl::Time approx_start = absl::Now();
absl::Duration grace = absl::Seconds(kGracePeriodSeconds);
absl::Duration max_duration = duration + grace;
options.set_max_session_duration_ms(absl::ToInt64Milliseconds(max_duration));
options.set_session_creation_timestamp_ns(absl::ToUnixNanos(approx_start));
ProfileRequest request =
PopulateProfileRequest(TmpDir(), "session_id", service_address, options);
absl::Status status;
auto sessions =
RemoteProfilerSessionManager::Create(options, request, status);
EXPECT_TRUE(status.ok());
std::vector<Response> responses = sessions->WaitForCompletion();
absl::Duration elapsed = absl::Now() - approx_start;
ASSERT_EQ(responses.size(), 1);
EXPECT_TRUE(responses.back().status.ok());
EXPECT_TRUE(responses.back().profile_response->empty_trace());
EXPECT_EQ(responses.back().profile_response->tool_data_size(), 0);
EXPECT_THAT(elapsed, DurationApproxLess(max_duration));
}
}
}
} |
2,636 | cpp | google/tsl | profiler_client | tsl/profiler/rpc/client/profiler_client.cc | tsl/profiler/rpc/client/profiler_client_test.cc | #ifndef TENSORFLOW_TSL_PROFILER_RPC_CLIENT_PROFILER_CLIENT_H_
#define TENSORFLOW_TSL_PROFILER_RPC_CLIENT_PROFILER_CLIENT_H_
#include <memory>
#include <string>
#include "absl/strings/string_view.h"
#include "absl/time/time.h"
#include "tsl/platform/status.h"
#include "tsl/profiler/protobuf/profiler_analysis.grpc.pb.h"
#include "tsl/profiler/protobuf/profiler_service.grpc.pb.h"
namespace tsl {
namespace profiler {
absl::Status ProfileGrpc(const std::string& service_address,
const tensorflow::ProfileRequest& request,
tensorflow::ProfileResponse* response);
absl::Status NewSessionGrpc(const std::string& service_address,
const tensorflow::NewProfileSessionRequest& request,
tensorflow::NewProfileSessionResponse* response);
absl::Status MonitorGrpc(const std::string& service_address,
const tensorflow::MonitorRequest& request,
tensorflow::MonitorResponse* response);
class RemoteProfilerSession {
public:
static std::unique_ptr<RemoteProfilerSession> Create(
const std::string& service_address, absl::Time deadline,
const tensorflow::ProfileRequest& profile_request);
RemoteProfilerSession(const RemoteProfilerSession&) = delete;
RemoteProfilerSession& operator=(const RemoteProfilerSession&) = delete;
~RemoteProfilerSession();
absl::string_view GetServiceAddress() const { return service_address_; }
std::unique_ptr<tensorflow::ProfileResponse> WaitForCompletion(
absl::Status& out_status);
private:
explicit RemoteProfilerSession(
const std::string& service_addr, absl::Time deadline,
const tensorflow::ProfileRequest& profile_request);
void ProfileAsync();
absl::Status status_on_completion_;
std::unique_ptr<tensorflow::ProfileResponse> response_;
std::string service_address_;
std::unique_ptr<tensorflow::grpc::ProfilerService::Stub> stub_;
absl::Time deadline_;
::grpc::ClientContext grpc_context_;
std::unique_ptr<
::grpc::ClientAsyncResponseReader<tensorflow::ProfileResponse>>
rpc_;
::grpc::Status grpc_status_ = ::grpc::Status::OK;
::grpc::CompletionQueue cq_;
tensorflow::ProfileRequest profile_request_;
};
}
}
#endif
#include "tsl/profiler/rpc/client/profiler_client.h"
#include <limits>
#include <memory>
#include "grpcpp/grpcpp.h"
#include "absl/memory/memory.h"
#include "absl/time/clock.h"
#include "absl/time/time.h"
#include "tsl/platform/errors.h"
#include "tsl/platform/logging.h"
#include "tsl/platform/status.h"
#include "tsl/platform/types.h"
#include "tsl/protobuf/error_codes.pb.h"
namespace tsl {
namespace profiler {
namespace {
using tensorflow::MonitorRequest;
using tensorflow::MonitorResponse;
using tensorflow::NewProfileSessionRequest;
using tensorflow::NewProfileSessionResponse;
using tensorflow::ProfileRequest;
using tensorflow::ProfileResponse;
inline absl::Status FromGrpcStatus(const ::grpc::Status& s) {
return s.ok() ? absl::OkStatus()
: absl::Status(static_cast<absl::StatusCode>(s.error_code()),
s.error_message());
}
template <typename T>
std::unique_ptr<typename T::Stub> CreateStub(
const std::string& service_address) {
::grpc::ChannelArguments channel_args;
channel_args.SetMaxReceiveMessageSize(std::numeric_limits<int32>::max());
auto channel = ::grpc::CreateCustomChannel(
service_address, ::grpc::InsecureChannelCredentials(), channel_args);
if (!channel) {
LOG(ERROR) << "Unable to create channel" << service_address;
return nullptr;
}
return T::NewStub(channel);
}
}
absl::Status ProfileGrpc(const std::string& service_address,
const ProfileRequest& request,
ProfileResponse* response) {
::grpc::ClientContext context;
std::unique_ptr<tensorflow::grpc::ProfilerService::Stub> stub =
CreateStub<tensorflow::grpc::ProfilerService>(service_address);
TF_RETURN_IF_ERROR(
FromGrpcStatus(stub->Profile(&context, request, response)));
return absl::OkStatus();
}
absl::Status NewSessionGrpc(const std::string& service_address,
const NewProfileSessionRequest& request,
NewProfileSessionResponse* response) {
::grpc::ClientContext context;
std::unique_ptr<tensorflow::grpc::ProfileAnalysis::Stub> stub =
CreateStub<tensorflow::grpc::ProfileAnalysis>(service_address);
TF_RETURN_IF_ERROR(
FromGrpcStatus(stub->NewSession(&context, request, response)));
return absl::OkStatus();
}
absl::Status MonitorGrpc(const std::string& service_address,
const MonitorRequest& request,
MonitorResponse* response) {
::grpc::ClientContext context;
std::unique_ptr<tensorflow::grpc::ProfilerService::Stub> stub =
CreateStub<tensorflow::grpc::ProfilerService>(service_address);
TF_RETURN_IF_ERROR(
FromGrpcStatus(stub->Monitor(&context, request, response)));
return absl::OkStatus();
}
std::unique_ptr<RemoteProfilerSession> RemoteProfilerSession::Create(
const std::string& service_address, absl::Time deadline,
const ProfileRequest& profile_request) {
auto instance = absl::WrapUnique(
new RemoteProfilerSession(service_address, deadline, profile_request));
instance->ProfileAsync();
return instance;
}
RemoteProfilerSession::RemoteProfilerSession(
const std::string& service_address, absl::Time deadline,
const ProfileRequest& profile_request)
: response_(absl::make_unique<ProfileResponse>()),
service_address_(service_address),
stub_(CreateStub<tensorflow::grpc::ProfilerService>(service_address_)),
deadline_(deadline),
profile_request_(profile_request) {
response_->set_empty_trace(true);
}
RemoteProfilerSession::~RemoteProfilerSession() {
absl::Status dummy;
WaitForCompletion(dummy);
grpc_context_.TryCancel();
}
void RemoteProfilerSession::ProfileAsync() {
LOG(INFO) << "Asynchronous gRPC Profile() to " << service_address_;
grpc_context_.set_deadline(absl::ToChronoTime(deadline_));
VLOG(1) << "Deadline set to " << deadline_;
rpc_ = stub_->AsyncProfile(&grpc_context_, profile_request_, &cq_);
rpc_->Finish(response_.get(), &grpc_status_,
static_cast<void*>(&status_on_completion_));
VLOG(2) << "Asynchronous gRPC Profile() issued." << absl::Now();
}
std::unique_ptr<ProfileResponse> RemoteProfilerSession::WaitForCompletion(
absl::Status& out_status) {
if (!response_) {
out_status = errors::FailedPrecondition(
"WaitForCompletion must only be called once.");
return nullptr;
}
LOG(INFO) << "Waiting for completion.";
void* got_tag = nullptr;
bool ok = false;
bool success = cq_.Next(&got_tag, &ok);
if (!success || !ok || got_tag == nullptr) {
out_status =
errors::Internal("Missing or invalid event from completion queue.");
return nullptr;
}
VLOG(1) << "Writing out status.";
DCHECK_EQ(got_tag, &status_on_completion_);
status_on_completion_.Update(FromGrpcStatus(grpc_status_));
if (status_on_completion_.code() == error::DEADLINE_EXCEEDED) {
LOG(WARNING) << status_on_completion_;
} else if (!status_on_completion_.ok()) {
LOG(ERROR) << status_on_completion_;
}
out_status = status_on_completion_;
return std::move(response_);
}
}
} | #include "tsl/profiler/rpc/client/profiler_client.h"
#include <memory>
#include <string>
#include "absl/time/clock.h"
#include "absl/time/time.h"
#include "tsl/platform/errors.h"
#include "tsl/platform/status.h"
#include "tsl/platform/test.h"
#include "tsl/platform/types.h"
#include "tsl/profiler/protobuf/profiler_service.pb.h"
#include "tsl/profiler/rpc/client/profiler_client_test_util.h"
namespace tsl {
namespace profiler {
namespace {
using tensorflow::ProfileRequest;
using ::tsl::profiler::test::DurationApproxLess;
using ::tsl::profiler::test::DurationNear;
using ::tsl::profiler::test::StartServer;
TEST(RemoteProfilerSession, Simple) {
absl::Duration duration = absl::Milliseconds(10);
ProfileRequest request;
std::string service_addr;
auto server = StartServer(duration, &service_addr, &request);
absl::Duration grace = absl::Seconds(1);
absl::Duration max_duration = duration + grace;
absl::Time approx_start = absl::Now();
absl::Time deadline = approx_start + max_duration;
auto remote_session =
RemoteProfilerSession::Create(service_addr, deadline, request);
absl::Status status;
auto response = remote_session->WaitForCompletion(status);
absl::Duration elapsed = absl::Now() - approx_start;
EXPECT_TRUE(status.ok());
EXPECT_TRUE(response->empty_trace());
EXPECT_EQ(response->tool_data_size(), 0);
EXPECT_THAT(elapsed, DurationApproxLess(max_duration));
}
TEST(RemoteProfilerSession, WaitNotCalled) {
absl::Duration duration = absl::Milliseconds(10);
ProfileRequest request;
std::string service_addr;
auto server = StartServer(duration, &service_addr, &request);
absl::Duration grace = absl::Seconds(1);
absl::Duration max_duration = duration + grace;
absl::Time approx_start = absl::Now();
absl::Time deadline = approx_start + max_duration;
auto remote_session =
RemoteProfilerSession::Create(service_addr, deadline, request);
absl::Duration elapsed = absl::Now() - approx_start;
EXPECT_THAT(elapsed, DurationApproxLess(max_duration));
}
TEST(RemoteProfilerSession, Timeout) {
absl::Duration duration = absl::Milliseconds(10);
ProfileRequest request;
std::string service_addr;
auto server = StartServer(duration, &service_addr, &request);
auto remote_session =
RemoteProfilerSession::Create(service_addr, absl::Now(), request);
absl::Status status;
auto response = remote_session->WaitForCompletion(status);
EXPECT_TRUE(errors::IsDeadlineExceeded(status));
EXPECT_TRUE(response->empty_trace());
EXPECT_EQ(response->tool_data_size(), 0);
}
TEST(RemoteProfilerSession, LongDeadline) {
absl::Duration duration = absl::Milliseconds(10);
ProfileRequest request;
std::string service_addr;
auto server = StartServer(duration, &service_addr, &request);
absl::Time approx_start = absl::Now();
absl::Duration grace = absl::Seconds(1000);
absl::Duration max_duration = duration + grace;
const absl::Time deadline = approx_start + max_duration;
auto remote_session =
RemoteProfilerSession::Create(service_addr, deadline, request);
absl::Status status;
auto response = remote_session->WaitForCompletion(status);
absl::Duration elapsed = absl::Now() - approx_start;
EXPECT_TRUE(status.ok());
EXPECT_TRUE(response->empty_trace());
EXPECT_EQ(response->tool_data_size(), 0);
EXPECT_THAT(elapsed, DurationNear(duration));
}
TEST(RemoteProfilerSession, LongDuration) {
absl::Duration duration = absl::Seconds(3);
ProfileRequest request;
std::string service_addr;
auto server = StartServer(duration, &service_addr, &request);
absl::Time approx_start = absl::Now();
absl::Duration grace = absl::Seconds(1);
absl::Duration max_duration = duration + grace;
const absl::Time deadline = approx_start + max_duration;
auto remote_session =
RemoteProfilerSession::Create(service_addr, deadline, request);
absl::Status status;
auto response = remote_session->WaitForCompletion(status);
absl::Duration elapsed = absl::Now() - approx_start;
EXPECT_TRUE(status.ok());
EXPECT_TRUE(response->empty_trace());
EXPECT_EQ(response->tool_data_size(), 0);
EXPECT_THAT(elapsed, DurationApproxLess(max_duration));
}
}
}
} |
2,637 | cpp | google/tsl | traceme_recorder | tsl/profiler/backends/cpu/traceme_recorder.cc | tsl/profiler/backends/cpu/traceme_recorder_test.cc | #ifndef TENSORFLOW_TSL_PROFILER_BACKENDS_CPU_TRACEME_RECORDER_H_
#define TENSORFLOW_TSL_PROFILER_BACKENDS_CPU_TRACEME_RECORDER_H_
#include <atomic>
#include <cstdint>
#include <deque>
#include <string>
#include <vector>
#include "tsl/platform/macros.h"
#include "tsl/platform/types.h"
namespace tsl {
namespace profiler {
namespace internal {
TF_EXPORT extern std::atomic<int> g_trace_level;
}
class TraceMeRecorder {
public:
struct Event {
bool IsComplete() const { return start_time > 0 && end_time > 0; }
bool IsStart() const { return end_time < 0; }
bool IsEnd() const { return start_time < 0; }
int64_t ActivityId() const {
if (IsStart()) return -end_time;
if (IsEnd()) return -start_time;
return 1;
}
std::string name;
int64_t start_time;
int64_t end_time;
};
struct ThreadInfo {
uint32 tid;
std::string name;
};
struct ThreadEvents {
ThreadInfo thread;
std::deque<Event> events;
};
using Events = std::vector<ThreadEvents>;
static bool Start(int level);
static Events Stop();
static inline bool Active(int level = 1) {
return internal::g_trace_level.load(std::memory_order_acquire) >= level;
}
static constexpr int kTracingDisabled = -1;
static void Record(Event&& event);
static int64_t NewActivityId();
private:
TraceMeRecorder() = delete;
~TraceMeRecorder() = delete;
static void Clear();
static TF_MUST_USE_RESULT Events Consume();
};
}
}
#endif
#include "tsl/profiler/backends/cpu/traceme_recorder.h"
#include <stddef.h>
#include <stdint.h>
#include <algorithm>
#include <atomic>
#include <deque>
#include <optional>
#include <utility>
#include <vector>
#include "absl/container/flat_hash_map.h"
#include "tsl/platform/env.h"
#include "tsl/platform/logging.h"
#include "tsl/platform/macros.h"
#include "tsl/platform/types.h"
#include "tsl/profiler/utils/lock_free_queue.h"
#include "tsl/profiler/utils/per_thread.h"
namespace tsl {
namespace profiler {
namespace internal {
#ifdef _WIN32
#define DECL_DLL_EXPORT __declspec(dllexport)
#else
#define DECL_DLL_EXPORT
#endif
DECL_DLL_EXPORT std::atomic<int> g_trace_level(
TraceMeRecorder::kTracingDisabled);
static_assert(ATOMIC_INT_LOCK_FREE == 2, "Assumed atomic<int> was lock free");
}
namespace {
class SplitEventTracker {
public:
void AddStart(TraceMeRecorder::Event&& event) {
DCHECK(event.IsStart());
start_events_.emplace(event.ActivityId(), std::move(event));
}
void AddEnd(TraceMeRecorder::Event* event) {
DCHECK(event->IsEnd());
if (!FindStartAndMerge(event)) {
end_events_.push_back(event);
}
}
void HandleCrossThreadEvents() {
for (auto* event : end_events_) {
FindStartAndMerge(event);
}
}
private:
bool FindStartAndMerge(TraceMeRecorder::Event* event) {
auto iter = start_events_.find(event->ActivityId());
if (iter == start_events_.end()) return false;
auto& start_event = iter->second;
event->name = std::move(start_event.name);
event->start_time = start_event.start_time;
start_events_.erase(iter);
return true;
}
absl::flat_hash_map<int64_t, TraceMeRecorder::Event> start_events_;
std::vector<TraceMeRecorder::Event*> end_events_;
};
class ThreadLocalRecorder {
public:
ThreadLocalRecorder() {
auto* env = Env::Default();
info_.tid = env->GetCurrentThreadId();
env->GetCurrentThreadName(&info_.name);
}
const TraceMeRecorder::ThreadInfo& Info() const { return info_; }
void Record(TraceMeRecorder::Event&& event) { queue_.Push(std::move(event)); }
void Clear() { queue_.Clear(); }
TF_MUST_USE_RESULT std::deque<TraceMeRecorder::Event> Consume(
SplitEventTracker* split_event_tracker) {
std::deque<TraceMeRecorder::Event> events;
std::optional<TraceMeRecorder::Event> event;
while ((event = queue_.Pop())) {
if (event->IsStart()) {
split_event_tracker->AddStart(*std::move(event));
continue;
}
events.push_back(*std::move(event));
if (events.back().IsEnd()) {
split_event_tracker->AddEnd(&events.back());
}
}
return events;
}
private:
TraceMeRecorder::ThreadInfo info_;
LockFreeQueue<TraceMeRecorder::Event> queue_;
};
}
void TraceMeRecorder::Clear() {
auto recorders = PerThread<ThreadLocalRecorder>::StartRecording();
for (auto& recorder : recorders) {
recorder->Clear();
};
}
TraceMeRecorder::Events TraceMeRecorder::Consume() {
TraceMeRecorder::Events result;
SplitEventTracker split_event_tracker;
auto recorders = PerThread<ThreadLocalRecorder>::StopRecording();
for (auto& recorder : recorders) {
auto events = recorder->Consume(&split_event_tracker);
if (!events.empty()) {
result.push_back({recorder->Info(), std::move(events)});
}
};
split_event_tracker.HandleCrossThreadEvents();
return result;
}
bool TraceMeRecorder::Start(int level) {
level = std::max(0, level);
int expected = kTracingDisabled;
bool started = internal::g_trace_level.compare_exchange_strong(
expected, level, std::memory_order_acq_rel);
if (started) {
Clear();
}
return started;
}
void TraceMeRecorder::Record(Event&& event) {
PerThread<ThreadLocalRecorder>::Get().Record(std::move(event));
}
TraceMeRecorder::Events TraceMeRecorder::Stop() {
TraceMeRecorder::Events events;
if (internal::g_trace_level.exchange(
kTracingDisabled, std::memory_order_acq_rel) != kTracingDisabled) {
events = Consume();
}
return events;
}
int64_t TraceMeRecorder::NewActivityId() {
static std::atomic<int32> thread_counter(1);
const thread_local static int32_t thread_id =
thread_counter.fetch_add(1, std::memory_order_relaxed);
thread_local static uint32 per_thread_activity_id = 0;
return static_cast<int64_t>(thread_id) << 32 | per_thread_activity_id++;
}
}
} | #include "tsl/profiler/backends/cpu/traceme_recorder.h"
#include <atomic>
#include <set>
#include <string>
#include <utility>
#include <vector>
#include "absl/container/flat_hash_map.h"
#include "absl/strings/numbers.h"
#include "absl/strings/str_cat.h"
#include "tsl/platform/env.h"
#include "tsl/platform/logging.h"
#include "tsl/platform/notification.h"
#include "tsl/platform/test.h"
#include "tsl/platform/threadpool.h"
#include "tsl/platform/types.h"
#include "tsl/profiler/utils/math_utils.h"
#include "tsl/profiler/utils/time_utils.h"
namespace tsl {
namespace profiler {
namespace {
using ::testing::ElementsAre;
MATCHER_P(Named, name, "") { return arg.name == name; }
TEST(RecorderTest, SingleThreaded) {
int64_t start_time = GetCurrentTimeNanos();
int64_t end_time = start_time + UniToNano(1);
TraceMeRecorder::Record({"before", start_time, end_time});
TraceMeRecorder::Start(1);
TraceMeRecorder::Record({"during1", start_time, end_time});
TraceMeRecorder::Record({"during2", start_time, end_time});
auto results = TraceMeRecorder::Stop();
TraceMeRecorder::Record({"after", start_time, end_time});
ASSERT_EQ(results.size(), 1);
EXPECT_THAT(results[0].events,
ElementsAre(Named("during1"), Named("during2")));
}
TEST(RecorderTest, Multithreaded) {
constexpr static int kNumThreads = 4;
tsl::Notification start;
tsl::Notification stop;
thread::ThreadPool pool(tsl::Env::Default(), "testpool", kNumThreads);
std::atomic<int> thread_count = {0};
for (int i = 0; i < kNumThreads; i++) {
pool.Schedule([&start, &stop, &thread_count] {
uint64 j = 0;
bool was_active = false;
auto record_event = [&j]() {
int64_t start_time = GetCurrentTimeNanos();
int64_t end_time = start_time + UniToNano(1);
TraceMeRecorder::Record(
{absl::StrCat(j++), start_time, end_time});
};
thread_count.fetch_add(1, std::memory_order_relaxed);
start.WaitForNotification();
while (!stop.HasBeenNotified()) {
if (TraceMeRecorder::Active()) {
record_event();
was_active = true;
}
if (was_active && !TraceMeRecorder::Active()) {
record_event();
record_event();
was_active = false;
}
SpinForNanos(10);
}
});
}
struct ThreadState {
bool split_session = false;
bool overlapping_sessions = false;
std::set<uint64> events;
};
absl::flat_hash_map<uint32 , ThreadState> thread_state;
auto done = [&thread_state] {
for (const auto& id_and_thread : thread_state) {
auto& t = id_and_thread.second;
if (t.events.size() < 2) return false;
}
return true;
};
while (thread_count.load(std::memory_order_relaxed) < kNumThreads) {
LOG(INFO) << "Waiting for all threads to spin up...";
SleepForMillis(1);
}
start.Notify();
constexpr static int kMaxIters = 100;
for (int iters = 0; iters < kMaxIters && !done(); ++iters) {
LOG(INFO) << "Looping until convergence, iteration: " << iters;
TraceMeRecorder::Start(1);
SleepForMillis(100);
auto results = TraceMeRecorder::Stop();
for (const auto& thread : results) {
if (thread.events.empty()) continue;
auto& state = thread_state[thread.thread.tid];
std::set<uint64> session_events;
uint64 current = 0;
for (const auto& event : thread.events) {
uint64 activity_id;
ASSERT_TRUE(absl::SimpleAtoi(event.name, &activity_id));
session_events.emplace(activity_id);
if (current != 0 && activity_id != current + 1) {
state.split_session = true;
}
current = activity_id;
}
for (const auto& event : session_events) {
auto result = state.events.emplace(event);
if (!result.second) {
state.overlapping_sessions = true;
}
}
}
SleepForMillis(1);
}
stop.Notify();
for (const auto& id_and_thread : thread_state) {
auto& thread = id_and_thread.second;
EXPECT_FALSE(thread.split_session)
<< "Expected contiguous events in a session";
EXPECT_FALSE(thread.overlapping_sessions) << "Expected disjoint sessions";
EXPECT_GT(thread.events.size(), 1)
<< "Expected gaps in thread events between sessions";
}
}
}
}
} |
2,638 | cpp | google/tsl | profiler_lock | tsl/profiler/lib/profiler_lock.cc | tsl/profiler/lib/profiler_lock_test.cc | #ifndef TENSORFLOW_TSL_PROFILER_LIB_PROFILER_LOCK_H_
#define TENSORFLOW_TSL_PROFILER_LIB_PROFILER_LOCK_H_
#include <utility>
#include "absl/status/statusor.h"
#include "absl/strings/string_view.h"
#include "tsl/platform/statusor.h"
namespace tsl {
namespace profiler {
constexpr absl::string_view kProfilerLockContention =
"Another profiling session active.";
class ProfilerLock {
public:
static bool HasActiveSession();
static absl::StatusOr<ProfilerLock> Acquire();
ProfilerLock() = default;
ProfilerLock(const ProfilerLock&) = delete;
ProfilerLock& operator=(const ProfilerLock&) = delete;
ProfilerLock(ProfilerLock&& other)
: active_(std::exchange(other.active_, false)) {}
ProfilerLock& operator=(ProfilerLock&& other) {
active_ = std::exchange(other.active_, false);
return *this;
}
~ProfilerLock() { ReleaseIfActive(); }
void ReleaseIfActive();
bool Active() const { return active_; }
private:
explicit ProfilerLock(bool active) : active_(active) {}
bool active_ = false;
};
}
}
#endif
#include "tsl/profiler/lib/profiler_lock.h"
#include <atomic>
#include "absl/status/statusor.h"
#include "xla/tsl/util/env_var.h"
#include "tsl/platform/errors.h"
#include "tsl/platform/macros.h"
namespace tsl {
namespace profiler {
namespace {
std::atomic<int> g_session_active = ATOMIC_VAR_INIT(0);
static_assert(ATOMIC_INT_LOCK_FREE == 2, "Assumed atomic<int> was lock free");
}
bool ProfilerLock::HasActiveSession() {
return g_session_active.load(std::memory_order_relaxed) != 0;
}
absl::StatusOr<ProfilerLock> ProfilerLock::Acquire() {
static bool tf_profiler_disabled = [] {
bool disabled = false;
ReadBoolFromEnvVar("TF_DISABLE_PROFILING", false, &disabled).IgnoreError();
return disabled;
}();
if (TF_PREDICT_FALSE(tf_profiler_disabled)) {
return errors::AlreadyExists(
"TensorFlow Profiler is permanently disabled by env var "
"TF_DISABLE_PROFILING.");
}
int already_active = g_session_active.exchange(1, std::memory_order_acq_rel);
if (already_active) {
return errors::AlreadyExists(kProfilerLockContention);
}
return ProfilerLock(true);
}
void ProfilerLock::ReleaseIfActive() {
if (active_) {
g_session_active.store(0, std::memory_order_release);
active_ = false;
}
}
}
} | #include "tsl/profiler/lib/profiler_lock.h"
#include <utility>
#include "absl/status/statusor.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace profiler {
namespace {
TEST(ProfilerLockTest, DefaultConstructorCreatesInactiveInstance) {
ProfilerLock profiler_lock;
EXPECT_FALSE(profiler_lock.Active());
}
TEST(ProfilerLockTest, AcquireAndReleaseExplicitly) {
absl::StatusOr<ProfilerLock> profiler_lock = ProfilerLock::Acquire();
ASSERT_TRUE(profiler_lock.ok());
EXPECT_TRUE(profiler_lock->Active());
profiler_lock->ReleaseIfActive();
EXPECT_FALSE(profiler_lock->Active());
}
TEST(ProfilerLockTest, AcquireAndReleaseOnDestruction) {
absl::StatusOr<ProfilerLock> profiler_lock = ProfilerLock::Acquire();
ASSERT_TRUE(profiler_lock.ok());
EXPECT_TRUE(profiler_lock->Active());
}
TEST(ProfilerLockTest, ReacquireWithoutReleaseFails) {
absl::StatusOr<ProfilerLock> profiler_lock_1 = ProfilerLock::Acquire();
absl::StatusOr<ProfilerLock> profiler_lock_2 = ProfilerLock::Acquire();
ASSERT_TRUE(profiler_lock_1.ok());
EXPECT_TRUE(profiler_lock_1->Active());
EXPECT_FALSE(profiler_lock_2.ok());
}
TEST(ProfilerLockTest, ReacquireAfterReleaseSucceeds) {
auto profiler_lock_1 = ProfilerLock::Acquire();
ASSERT_TRUE(profiler_lock_1.ok());
ASSERT_TRUE(profiler_lock_1->Active());
profiler_lock_1->ReleaseIfActive();
ASSERT_FALSE(profiler_lock_1->Active());
auto profiler_lock_2 = ProfilerLock::Acquire();
EXPECT_TRUE(profiler_lock_2.ok());
EXPECT_TRUE(profiler_lock_2->Active());
}
TEST(ProfilerLockTest, InactiveAfterMove) {
absl::StatusOr<ProfilerLock> profiler_lock_1 = ProfilerLock::Acquire();
ASSERT_TRUE(profiler_lock_1.ok());
ASSERT_TRUE(profiler_lock_1->Active());
ProfilerLock profiler_lock_2 = std::move(*profiler_lock_1);
EXPECT_FALSE(profiler_lock_1->Active());
EXPECT_TRUE(profiler_lock_2.Active());
}
}
}
} |
2,639 | cpp | google/tsl | profiler_factory | tsl/profiler/lib/profiler_factory.cc | tsl/profiler/lib/profiler_factory_test.cc | #ifndef TENSORFLOW_TSL_PROFILER_LIB_PROFILER_FACTORY_H_
#define TENSORFLOW_TSL_PROFILER_LIB_PROFILER_FACTORY_H_
#include <functional>
#include <memory>
#include <vector>
#include "tsl/profiler/lib/profiler_interface.h"
#include "tsl/profiler/protobuf/profiler_options.pb.h"
namespace tsl {
namespace profiler {
using ProfilerFactory = std::function<std::unique_ptr<ProfilerInterface>(
const tensorflow::ProfileOptions&)>;
void RegisterProfilerFactory(ProfilerFactory factory);
std::vector<std::unique_ptr<ProfilerInterface>> CreateProfilers(
const tensorflow::ProfileOptions& options);
void ClearRegisteredProfilersForTest();
}
}
#endif
#include "tsl/profiler/lib/profiler_factory.h"
#include <memory>
#include <utility>
#include <vector>
#include "tsl/platform/mutex.h"
#include "tsl/profiler/lib/profiler_controller.h"
#include "tsl/profiler/lib/profiler_interface.h"
#include "tsl/profiler/protobuf/profiler_options.pb.h"
namespace tsl {
namespace profiler {
namespace {
mutex mu(LINKER_INITIALIZED);
std::vector<ProfilerFactory>* GetFactories() {
static auto factories = new std::vector<ProfilerFactory>();
return factories;
}
}
void RegisterProfilerFactory(ProfilerFactory factory) {
mutex_lock lock(mu);
GetFactories()->push_back(std::move(factory));
}
std::vector<std::unique_ptr<profiler::ProfilerInterface>> CreateProfilers(
const tensorflow::ProfileOptions& options) {
std::vector<std::unique_ptr<profiler::ProfilerInterface>> result;
mutex_lock lock(mu);
for (const auto& factory : *GetFactories()) {
auto profiler = factory(options);
if (profiler == nullptr) continue;
result.emplace_back(
std::make_unique<ProfilerController>(std::move(profiler)));
}
return result;
}
void ClearRegisteredProfilersForTest() {
mutex_lock lock(mu);
GetFactories()->clear();
}
}
} | #include "tsl/profiler/lib/profiler_factory.h"
#include <functional>
#include <utility>
#include "absl/memory/memory.h"
#include "absl/status/status.h"
#include "tsl/platform/macros.h"
#include "tsl/platform/test.h"
#include "tsl/profiler/lib/profiler_interface.h"
#include "tsl/profiler/protobuf/profiler_options.pb.h"
#include "tsl/profiler/protobuf/xplane.pb.h"
namespace tsl {
namespace profiler {
namespace {
class TestProfiler : public ProfilerInterface {
public:
absl::Status Start() override { return absl::OkStatus(); }
absl::Status Stop() override { return absl::OkStatus(); }
absl::Status CollectData(tensorflow::profiler::XSpace*) override {
return absl::OkStatus();
}
};
std::unique_ptr<ProfilerInterface> TestFactoryFunction(
const tensorflow::ProfileOptions& options) {
return absl::make_unique<TestProfiler>();
}
TEST(ProfilerFactoryTest, FactoryFunctionPointer) {
ClearRegisteredProfilersForTest();
RegisterProfilerFactory(&TestFactoryFunction);
auto profilers = CreateProfilers(tensorflow::ProfileOptions());
EXPECT_EQ(profilers.size(), 1);
}
TEST(ProfilerFactoryTest, FactoryLambda) {
ClearRegisteredProfilersForTest();
RegisterProfilerFactory([](const tensorflow::ProfileOptions& options) {
return absl::make_unique<TestProfiler>();
});
auto profilers = CreateProfilers(tensorflow::ProfileOptions());
EXPECT_EQ(profilers.size(), 1);
}
std::unique_ptr<ProfilerInterface> NullFactoryFunction(
const tensorflow::ProfileOptions& options) {
return nullptr;
}
TEST(ProfilerFactoryTest, FactoryReturnsNull) {
ClearRegisteredProfilersForTest();
RegisterProfilerFactory(&NullFactoryFunction);
auto profilers = CreateProfilers(tensorflow::ProfileOptions());
EXPECT_TRUE(profilers.empty());
}
class FactoryClass {
public:
explicit FactoryClass(void* ptr) : ptr_(ptr) {}
FactoryClass(const FactoryClass&) = default;
FactoryClass(FactoryClass&&) = default;
std::unique_ptr<ProfilerInterface> CreateProfiler(
const tensorflow::ProfileOptions& options) const {
return absl::make_unique<TestProfiler>();
}
private:
void* ptr_ TF_ATTRIBUTE_UNUSED = nullptr;
};
TEST(ProfilerFactoryTest, FactoryClassCapturedByLambda) {
ClearRegisteredProfilersForTest();
static int token = 42;
FactoryClass factory(&token);
RegisterProfilerFactory([factory = std::move(factory)](
const tensorflow::ProfileOptions& options) {
return factory.CreateProfiler(options);
});
auto profilers = CreateProfilers(tensorflow::ProfileOptions());
EXPECT_EQ(profilers.size(), 1);
}
}
}
} |
2,640 | cpp | google/tsl | weighted_picker | tsl/lib/random/weighted_picker.cc | tsl/lib/random/weighted_picker_test.cc | #ifndef TENSORFLOW_TSL_LIB_RANDOM_WEIGHTED_PICKER_H_
#define TENSORFLOW_TSL_LIB_RANDOM_WEIGHTED_PICKER_H_
#include <assert.h>
#include "tsl/platform/logging.h"
#include "tsl/platform/macros.h"
#include "tsl/platform/types.h"
namespace tsl {
namespace random {
class SimplePhilox;
class WeightedPicker {
public:
explicit WeightedPicker(int N);
~WeightedPicker();
int Pick(SimplePhilox* rnd) const;
int PickAt(int32_t weight_index) const;
int32 get_weight(int index) const;
void set_weight(int index, int32_t weight);
int32 total_weight() const;
int num_elements() const;
void SetAllWeights(int32_t weight);
void SetWeightsFromArray(int N, const int32* weights);
void Resize(int N);
void Append(int32_t weight);
private:
int N_;
int num_levels_;
int32** level_;
static int LevelSize(int level) { return 1 << level; }
void RebuildTreeWeights();
WeightedPicker(const WeightedPicker&) = delete;
void operator=(const WeightedPicker&) = delete;
};
inline int32 WeightedPicker::get_weight(int index) const {
DCHECK_GE(index, 0);
DCHECK_LT(index, N_);
return level_[num_levels_ - 1][index];
}
inline int32 WeightedPicker::total_weight() const { return level_[0][0]; }
inline int WeightedPicker::num_elements() const { return N_; }
}
}
#endif
#include "tsl/lib/random/weighted_picker.h"
#include <string.h>
#include <algorithm>
#include "tsl/lib/random/simple_philox.h"
namespace tsl {
namespace random {
WeightedPicker::WeightedPicker(int N) {
CHECK_GE(N, 0);
N_ = N;
num_levels_ = 1;
while (LevelSize(num_levels_ - 1) < N) {
num_levels_++;
}
level_ = new int32*[num_levels_];
for (int l = 0; l < num_levels_; l++) {
level_[l] = new int32[LevelSize(l)];
}
SetAllWeights(1);
}
WeightedPicker::~WeightedPicker() {
for (int l = 0; l < num_levels_; l++) {
delete[] level_[l];
}
delete[] level_;
}
static int32 UnbiasedUniform(SimplePhilox* r, int32_t n) {
CHECK_LE(0, n);
const uint32 range = ~static_cast<uint32>(0);
if (n == 0) {
return r->Rand32() * n;
} else if (0 == (n & (n - 1))) {
return r->Rand32() & (n - 1);
} else {
uint32 rem = (range % n) + 1;
uint32 rnd;
do {
rnd = r->Rand32();
} while (rnd < rem);
return rnd % n;
}
}
int WeightedPicker::Pick(SimplePhilox* rnd) const {
if (total_weight() == 0) return -1;
return PickAt(UnbiasedUniform(rnd, total_weight()));
}
int WeightedPicker::PickAt(int32_t weight_index) const {
if (weight_index < 0 || weight_index >= total_weight()) return -1;
int32_t position = weight_index;
int index = 0;
for (int l = 1; l < num_levels_; l++) {
const int32_t left_weight = level_[l][2 * index];
if (position < left_weight) {
index = 2 * index;
} else {
index = 2 * index + 1;
position -= left_weight;
}
}
CHECK_GE(index, 0);
CHECK_LT(index, N_);
CHECK_LE(position, level_[num_levels_ - 1][index]);
return index;
}
void WeightedPicker::set_weight(int index, int32_t weight) {
assert(index >= 0);
assert(index < N_);
const int32_t delta = weight - get_weight(index);
for (int l = num_levels_ - 1; l >= 0; l--) {
level_[l][index] += delta;
index >>= 1;
}
}
void WeightedPicker::SetAllWeights(int32_t weight) {
int32* leaves = level_[num_levels_ - 1];
for (int i = 0; i < N_; i++) leaves[i] = weight;
for (int i = N_; i < LevelSize(num_levels_ - 1); i++) leaves[i] = 0;
RebuildTreeWeights();
}
void WeightedPicker::SetWeightsFromArray(int N, const int32* weights) {
Resize(N);
int32* leaves = level_[num_levels_ - 1];
for (int i = 0; i < N_; i++) leaves[i] = weights[i];
for (int i = N_; i < LevelSize(num_levels_ - 1); i++) leaves[i] = 0;
RebuildTreeWeights();
}
void WeightedPicker::RebuildTreeWeights() {
for (int l = num_levels_ - 2; l >= 0; l--) {
int32* level = level_[l];
int32* children = level_[l + 1];
for (int i = 0; i < LevelSize(l); i++) {
level[i] = children[2 * i] + children[2 * i + 1];
}
}
}
void WeightedPicker::Append(int32_t weight) {
Resize(num_elements() + 1);
set_weight(num_elements() - 1, weight);
}
void WeightedPicker::Resize(int new_size) {
CHECK_GE(new_size, 0);
if (new_size <= LevelSize(num_levels_ - 1)) {
for (int i = new_size; i < N_; i++) {
set_weight(i, 0);
}
N_ = new_size;
return;
}
assert(new_size > N_);
WeightedPicker new_picker(new_size);
int32* dst = new_picker.level_[new_picker.num_levels_ - 1];
int32* src = this->level_[this->num_levels_ - 1];
memcpy(dst, src, sizeof(dst[0]) * N_);
memset(dst + N_, 0, sizeof(dst[0]) * (new_size - N_));
new_picker.RebuildTreeWeights();
std::swap(new_picker.N_, this->N_);
std::swap(new_picker.num_levels_, this->num_levels_);
std::swap(new_picker.level_, this->level_);
assert(this->N_ == new_size);
}
}
} | #include "tsl/lib/random/weighted_picker.h"
#include <string.h>
#include <vector>
#include "tsl/lib/random/simple_philox.h"
#include "tsl/platform/logging.h"
#include "tsl/platform/macros.h"
#include "tsl/platform/test.h"
#include "tsl/platform/test_benchmark.h"
#include "tsl/platform/types.h"
namespace tsl {
namespace random {
static void TestPicker(SimplePhilox* rnd, int size);
static void CheckUniform(SimplePhilox* rnd, WeightedPicker* picker, int trials);
static void CheckSkewed(SimplePhilox* rnd, WeightedPicker* picker, int trials);
static void TestPickAt(int items, const int32* weights);
TEST(WeightedPicker, Simple) {
PhiloxRandom philox(testing::RandomSeed(), 17);
SimplePhilox rnd(&philox);
{
VLOG(0) << "======= Zero-length picker";
WeightedPicker picker(0);
EXPECT_EQ(picker.Pick(&rnd), -1);
}
{
VLOG(0) << "======= Singleton picker";
WeightedPicker picker(1);
EXPECT_EQ(picker.Pick(&rnd), 0);
EXPECT_EQ(picker.Pick(&rnd), 0);
EXPECT_EQ(picker.Pick(&rnd), 0);
}
{
VLOG(0) << "======= Grown picker";
WeightedPicker picker(0);
for (int i = 0; i < 10; i++) {
picker.Append(1);
}
CheckUniform(&rnd, &picker, 100000);
}
{
VLOG(0) << "======= Grown picker with zero weights";
WeightedPicker picker(1);
picker.Resize(10);
EXPECT_EQ(picker.Pick(&rnd), 0);
EXPECT_EQ(picker.Pick(&rnd), 0);
EXPECT_EQ(picker.Pick(&rnd), 0);
}
{
VLOG(0) << "======= Shrink picker and check weights";
WeightedPicker picker(1);
picker.Resize(10);
EXPECT_EQ(picker.Pick(&rnd), 0);
EXPECT_EQ(picker.Pick(&rnd), 0);
EXPECT_EQ(picker.Pick(&rnd), 0);
for (int i = 0; i < 10; i++) {
picker.set_weight(i, i);
}
EXPECT_EQ(picker.total_weight(), 45);
picker.Resize(5);
EXPECT_EQ(picker.total_weight(), 10);
picker.Resize(2);
EXPECT_EQ(picker.total_weight(), 1);
picker.Resize(1);
EXPECT_EQ(picker.total_weight(), 0);
}
}
TEST(WeightedPicker, BigWeights) {
PhiloxRandom philox(testing::RandomSeed() + 1, 17);
SimplePhilox rnd(&philox);
VLOG(0) << "======= Check uniform with big weights";
WeightedPicker picker(2);
picker.SetAllWeights(2147483646L / 3);
CheckUniform(&rnd, &picker, 100000);
}
TEST(WeightedPicker, Deterministic) {
VLOG(0) << "======= Testing deterministic pick";
static const int32 weights[] = {1, 0, 200, 5, 42};
TestPickAt(TF_ARRAYSIZE(weights), weights);
}
TEST(WeightedPicker, Randomized) {
PhiloxRandom philox(testing::RandomSeed() + 10, 17);
SimplePhilox rnd(&philox);
TestPicker(&rnd, 1);
TestPicker(&rnd, 2);
TestPicker(&rnd, 3);
TestPicker(&rnd, 4);
TestPicker(&rnd, 7);
TestPicker(&rnd, 8);
TestPicker(&rnd, 9);
TestPicker(&rnd, 10);
TestPicker(&rnd, 100);
}
static void TestPicker(SimplePhilox* rnd, int size) {
VLOG(0) << "======= Testing size " << size;
{
WeightedPicker picker(size);
picker.SetAllWeights(0);
for (int i = 0; i < 100; i++) EXPECT_EQ(picker.Pick(rnd), -1);
}
std::vector<int32> weights(size);
for (int elem = 0; elem < size; elem++) {
weights[elem] = 0;
}
for (int elem = 0; elem < size; elem++) {
WeightedPicker picker(size);
picker.SetAllWeights(0);
picker.set_weight(elem, elem + 1);
for (int i = 0; i < 100; i++) EXPECT_EQ(picker.Pick(rnd), elem);
weights[elem] = 10;
picker.SetWeightsFromArray(size, &weights[0]);
for (int i = 0; i < 100; i++) EXPECT_EQ(picker.Pick(rnd), elem);
weights[elem] = 0;
}
{
WeightedPicker picker(size);
CheckUniform(rnd, &picker, 100000);
}
if (size / 3 > 0) {
WeightedPicker picker(size / 3);
while (picker.num_elements() != size) {
picker.Append(1);
}
CheckUniform(rnd, &picker, 100000);
}
if (size <= 10) {
WeightedPicker picker(size);
int32_t weight = 1;
for (int elem = 0; elem < size; elem++) {
picker.set_weight(elem, weight);
weights[elem] = weight;
weight *= 2;
}
CheckSkewed(rnd, &picker, 1000000);
WeightedPicker array_picker(0);
array_picker.SetWeightsFromArray(size, &weights[0]);
CheckSkewed(rnd, &array_picker, 1000000);
}
}
static void CheckUniform(SimplePhilox* rnd, WeightedPicker* picker,
int trials) {
const int size = picker->num_elements();
int* count = new int[size];
memset(count, 0, sizeof(count[0]) * size);
for (int i = 0; i < size * trials; i++) {
const int elem = picker->Pick(rnd);
EXPECT_GE(elem, 0);
EXPECT_LT(elem, size);
count[elem]++;
}
const int expected_min = int(0.9 * trials);
const int expected_max = int(1.1 * trials);
for (int i = 0; i < size; i++) {
EXPECT_GE(count[i], expected_min);
EXPECT_LE(count[i], expected_max);
}
delete[] count;
}
static void CheckSkewed(SimplePhilox* rnd, WeightedPicker* picker, int trials) {
const int size = picker->num_elements();
int* count = new int[size];
memset(count, 0, sizeof(count[0]) * size);
for (int i = 0; i < size * trials; i++) {
const int elem = picker->Pick(rnd);
EXPECT_GE(elem, 0);
EXPECT_LT(elem, size);
count[elem]++;
}
for (int i = 0; i < size - 1; i++) {
LOG(INFO) << i << ": " << count[i];
const float ratio = float(count[i + 1]) / float(count[i]);
EXPECT_GE(ratio, 1.6f);
EXPECT_LE(ratio, 2.4f);
}
delete[] count;
}
static void TestPickAt(int items, const int32* weights) {
WeightedPicker picker(items);
picker.SetWeightsFromArray(items, weights);
int weight_index = 0;
for (int i = 0; i < items; ++i) {
for (int j = 0; j < weights[i]; ++j) {
int pick = picker.PickAt(weight_index);
EXPECT_EQ(pick, i);
++weight_index;
}
}
EXPECT_EQ(weight_index, picker.total_weight());
}
static void BM_Create(::testing::benchmark::State& state) {
int arg = state.range(0);
for (auto s : state) {
WeightedPicker p(arg);
}
}
BENCHMARK(BM_Create)->Range(1, 1024);
static void BM_CreateAndSetWeights(::testing::benchmark::State& state) {
int arg = state.range(0);
std::vector<int32> weights(arg);
for (int i = 0; i < arg; i++) {
weights[i] = i * 10;
}
for (auto s : state) {
WeightedPicker p(arg);
p.SetWeightsFromArray(arg, &weights[0]);
}
}
BENCHMARK(BM_CreateAndSetWeights)->Range(1, 1024);
static void BM_Pick(::testing::benchmark::State& state) {
int arg = state.range(0);
PhiloxRandom philox(301, 17);
SimplePhilox rnd(&philox);
WeightedPicker p(arg);
int result = 0;
for (auto s : state) {
result += p.Pick(&rnd);
}
VLOG(4) << result;
}
BENCHMARK(BM_Pick)->Range(1, 1024);
}
} |
2,641 | cpp | google/tsl | random_distributions | tsl/lib/random/random_distributions.cc | tsl/lib/random/random_distributions_test.cc | #ifndef TENSORFLOW_TSL_LIB_RANDOM_RANDOM_DISTRIBUTIONS_H_
#define TENSORFLOW_TSL_LIB_RANDOM_RANDOM_DISTRIBUTIONS_H_
#include <algorithm>
#include <cmath>
#include <type_traits>
#include "unsupported/Eigen/CXX11/Tensor"
#include "tsl/lib/random/philox_random.h"
#include "tsl/lib/random/random_distributions_utils.h"
#include "tsl/platform/types.h"
namespace tsl {
namespace random {
PHILOX_DEVICE_INLINE Eigen::half Uint16ToHalf(uint16 x);
PHILOX_DEVICE_INLINE bfloat16 Uint16ToGfloat16(uint16 x);
template <typename Int>
PHILOX_DEVICE_INLINE Int SignedAdd(Int a,
typename std::make_unsigned<Int>::type b) {
auto b_div_2 = b >> 1;
return a + static_cast<Int>(b_div_2) + static_cast<Int>(b - b_div_2);
}
template <class Generator, typename RealType>
class UniformDistribution;
template <class Generator>
class UniformDistribution<Generator, Eigen::half> {
public:
static constexpr int kResultElementCount = Generator::kResultElementCount;
static constexpr int kElementCost = 3;
static constexpr bool kVariableSamplesPerOutput = false;
typedef Array<Eigen::half, kResultElementCount> ResultType;
typedef Eigen::half ResultElementType;
PHILOX_DEVICE_INLINE
ResultType operator()(Generator* gen) {
typename Generator::ResultType sample = (*gen)();
ResultType result;
for (int i = 0; i < kResultElementCount; ++i) {
result[i] = Uint16ToHalf(sample[i]);
}
return result;
}
};
template <class Generator>
class UniformDistribution<Generator, bfloat16> {
public:
static constexpr int kResultElementCount = Generator::kResultElementCount;
static constexpr int kElementCost = 3;
static constexpr bool kVariableSamplesPerOutput = false;
typedef Array<bfloat16, kResultElementCount> ResultType;
typedef bfloat16 ResultElementType;
PHILOX_DEVICE_INLINE
ResultType operator()(Generator* gen) {
typename Generator::ResultType sample = (*gen)();
ResultType result;
for (int i = 0; i < kResultElementCount; ++i) {
result[i] = Uint16ToGfloat16(sample[i]);
}
return result;
}
};
template <class Generator>
class UniformDistribution<Generator, float> {
public:
static constexpr int kResultElementCount = Generator::kResultElementCount;
static constexpr int kElementCost = 3;
static constexpr bool kVariableSamplesPerOutput = false;
typedef Array<float, kResultElementCount> ResultType;
typedef float ResultElementType;
PHILOX_DEVICE_INLINE
ResultType operator()(Generator* gen) {
typename Generator::ResultType sample = (*gen)();
ResultType result;
for (int i = 0; i < kResultElementCount; ++i) {
result[i] = Uint32ToFloat(sample[i]);
}
return result;
}
};
template <class Generator>
class UniformDistribution<Generator, double> {
public:
static constexpr int kResultElementCount = Generator::kResultElementCount / 2;
static constexpr int kElementCost = 3;
static constexpr bool kVariableSamplesPerOutput = false;
typedef Array<double, kResultElementCount> ResultType;
typedef double ResultElementType;
PHILOX_DEVICE_INLINE
ResultType operator()(Generator* gen) {
typename Generator::ResultType sample = (*gen)();
ResultType result;
for (int i = 0; i < kResultElementCount; ++i) {
result[i] = Uint64ToDouble(sample[2 * i], sample[2 * i + 1]);
}
return result;
}
};
template <class Generator>
class UniformDistribution<Generator, int32> {
public:
static constexpr int kResultElementCount = Generator::kResultElementCount;
static constexpr int kElementCost = 3;
static constexpr bool kVariableSamplesPerOutput = false;
typedef Array<int32, kResultElementCount> ResultType;
typedef int32 ResultElementType;
UniformDistribution(int32_t lo, int32_t hi)
: lo_(lo), range_(static_cast<uint32>(hi) - static_cast<uint32>(lo)) {}
PHILOX_DEVICE_INLINE
ResultType operator()(Generator* gen) {
typename Generator::ResultType sample = (*gen)();
ResultType result;
for (int i = 0; i < kResultElementCount; ++i) {
result[i] = SignedAdd(lo_, sample[i] % range_);
}
return result;
}
private:
int32 lo_;
uint32 range_;
};
template <class Generator>
class UniformDistribution<Generator, int64_t> {
public:
static constexpr int kResultElementCount = Generator::kResultElementCount / 2;
static constexpr int kElementCost = 3;
static constexpr bool kVariableSamplesPerOutput = false;
typedef Array<int64_t, kResultElementCount> ResultType;
typedef int64_t ResultElementType;
UniformDistribution(int64_t lo, int64_t hi)
: lo_(lo), range_(static_cast<uint64>(hi) - static_cast<uint64>(lo)) {}
PHILOX_DEVICE_INLINE
ResultType operator()(Generator* gen) {
typename Generator::ResultType sample = (*gen)();
ResultType result;
for (int i = 0; i < kResultElementCount; ++i) {
auto bits = sample[2 * i] | static_cast<uint64>(sample[2 * i + 1]) << 32;
result[i] = SignedAdd(lo_, bits % range_);
}
return result;
}
private:
int64_t lo_;
uint64 range_;
};
template <typename Generator, typename IntType>
class UniformFullIntDistribution;
template <typename Generator, typename IntType>
class UniformFullIntDistribution32 {
public:
static constexpr int kResultElementCount = Generator::kResultElementCount;
static constexpr int kElementCost = 3;
static constexpr bool kVariableSamplesPerOutput = false;
typedef Array<IntType, kResultElementCount> ResultType;
typedef IntType ResultElementType;
PHILOX_DEVICE_INLINE
ResultType operator()(Generator* gen) {
typename Generator::ResultType sample = (*gen)();
ResultType result;
for (int i = 0; i < kResultElementCount; ++i) {
result[i] = sample[i];
}
return result;
}
};
template <typename Generator, typename IntType>
class UniformFullIntDistribution64 {
public:
static constexpr int kResultElementCount = Generator::kResultElementCount / 2;
static constexpr int kElementCost = 3;
static constexpr bool kVariableSamplesPerOutput = false;
typedef Array<IntType, kResultElementCount> ResultType;
typedef IntType ResultElementType;
PHILOX_DEVICE_INLINE
ResultType operator()(Generator* gen) {
typename Generator::ResultType sample = (*gen)();
ResultType result;
for (int i = 0; i < kResultElementCount; ++i) {
result[i] = sample[2 * i] | static_cast<uint64>(sample[2 * i + 1]) << 32;
}
return result;
}
};
template <typename Generator>
class UniformFullIntDistribution<Generator, int32>
: public UniformFullIntDistribution32<Generator, int32> {};
template <typename Generator>
class UniformFullIntDistribution<Generator, uint32>
: public UniformFullIntDistribution32<Generator, uint32> {};
template <typename Generator>
class UniformFullIntDistribution<Generator, int64_t>
: public UniformFullIntDistribution64<Generator, int64_t> {};
template <typename Generator>
class UniformFullIntDistribution<Generator, uint64>
: public UniformFullIntDistribution64<Generator, uint64> {};
template <class Generator>
class SingleSampleAdapter {
public:
static constexpr int kResultElementCount = 1;
static constexpr int kNativeElementCount = Generator::kResultElementCount;
typedef typename Generator::ResultElementType ResultType;
typedef typename Generator::ResultElementType ResultElementType;
PHILOX_DEVICE_INLINE
explicit SingleSampleAdapter(Generator* gen)
: generator_(gen), used_result_index_(Generator::kResultElementCount) {}
PHILOX_DEVICE_INLINE
ResultType operator()() {
if (used_result_index_ == Generator::kResultElementCount) {
unused_results_ = (*generator_)();
used_result_index_ = 0;
}
return unused_results_[used_result_index_++];
}
PHILOX_DEVICE_INLINE
void Skip(uint64 num_skips) {
if (!num_skips) {
return;
}
int num_unused_results = kNativeElementCount - used_result_index_;
if (num_skips <= num_unused_results) {
used_result_index_ += num_skips;
return;
}
num_skips -= num_unused_results;
used_result_index_ = kNativeElementCount;
SkipFromGenerator(num_skips / kNativeElementCount);
num_skips = num_skips % kNativeElementCount;
if (num_skips) {
unused_results_ = (*generator_)();
used_result_index_ = num_skips;
}
}
private:
PHILOX_DEVICE_INLINE
void SkipFromGenerator(uint64 num_skips) {
while (num_skips--) {
(*generator_)();
}
}
Generator* generator_;
typename Generator::ResultType unused_results_;
int used_result_index_;
};
template <class Generator, typename RealType>
class NormalDistribution;
PHILOX_DEVICE_INLINE
void BoxMullerDouble(uint32 x0, uint32 x1, uint32 x2, uint32 x3, double* d0,
double* d1);
template <class Generator>
class NormalDistribution<Generator, Eigen::half> {
public:
static constexpr int kResultElementCount = Generator::kResultElementCount;
static constexpr int kElementCost = 70;
static constexpr bool kVariableSamplesPerOutput = false;
typedef Array<Eigen::half, kResultElementCount> ResultType;
typedef Eigen::half ResultElementType;
PHILOX_DEVICE_INLINE
ResultType operator()(Generator* gen) {
typename Generator::ResultType sample = (*gen)();
ResultType result;
for (int i = 0; i < kResultElementCount; i += 2) {
float f[2];
BoxMullerFloat(sample[i], sample[i + 1], &f[0], &f[1]);
result[i] = Eigen::half(f[0]);
result[i + 1] = Eigen::half(f[1]);
}
return result;
}
};
template <class Generator>
class NormalDistribution<Generator, bfloat16> {
public:
static constexpr int kResultElementCount = Generator::kResultElementCount;
static constexpr int kElementCost = 70;
static constexpr bool kVariableSamplesPerOutput = false;
typedef Array<bfloat16, kResultElementCount> ResultType;
typedef bfloat16 ResultElementType;
PHILOX_DEVICE_INLINE
ResultType operator()(Generator* gen) {
typename Generator::ResultType sample = (*gen)();
ResultType result;
static_assert(kResultElementCount % 2 == 0,
"kResultElementCount should be an even number");
for (int i = 0; i < kResultElementCount; i += 2) {
float f[2];
BoxMullerFloat(sample[i], sample[i + 1], &f[0], &f[1]);
result[i] = bfloat16(f[0]);
result[i + 1] = bfloat16(f[1]);
}
return result;
}
};
template <class Generator>
class NormalDistribution<Generator, float> {
public:
static constexpr int kResultElementCount = Generator::kResultElementCount;
static constexpr int kElementCost = 70;
static constexpr bool kVariableSamplesPerOutput = false;
typedef Array<float, kResultElementCount> ResultType;
typedef float ResultElementType;
PHILOX_DEVICE_INLINE
ResultType operator()(Generator* gen) {
typename Generator::ResultType sample = (*gen)();
ResultType result;
for (int i = 0; i < kResultElementCount; i += 2) {
BoxMullerFloat(sample[i], sample[i + 1], &result[i], &result[i + 1]);
}
return result;
}
};
template <class Generator>
class NormalDistribution<Generator, double> {
public:
static constexpr int kResultElementCount = Generator::kResultElementCount / 2;
static constexpr int kElementCost = 70;
static constexpr bool kVariableSamplesPerOutput = false;
typedef Array<double, kResultElementCount> ResultType;
typedef double ResultElementType;
PHILOX_DEVICE_INLINE
ResultType operator()(Generator* gen) {
typename Generator::ResultType sample = (*gen)();
ResultType result;
for (int i = 0; i < kResultElementCount; i += 2) {
const int i2 = 2 * i;
BoxMullerDouble(sample[i2], sample[i2 + 1], sample[i2 + 2],
sample[i2 + 3], &result[i], &result[i + 1]);
}
return result;
}
};
template <class SingleSampleGenerator, typename RealType>
class TruncatedNormalDistribution;
template <class SingleSampleGenerator>
class TruncatedNormalDistribution<SingleSampleGenerator, Eigen::half> {
public:
static constexpr int kResultElementCount =
SingleSampleGenerator::kNativeElementCount;
static constexpr int kElementCost = 90;
static constexpr bool kVariableSamplesPerOutput = true;
const float kTruncateValue = 2.0f;
typedef Array<Eigen::half, kResultElementCount> ResultType;
typedef Eigen::half ResultElementType;
PHILOX_DEVICE_INLINE
ResultType operator()(SingleSampleGenerator* gen) {
ResultType results;
int index = 0;
while (true) {
const uint32 x0 = (*gen)();
const uint32 x1 = (*gen)();
float f[2];
BoxMullerFloat(x0, x1, &f[0], &f[1]);
if (Eigen::numext::abs(f[0]) < kTruncateValue) {
results[index++] = Eigen::half(f[0]);
if (index >= kResultElementCount) {
return results;
}
}
if (Eigen::numext::abs(f[1]) < kTruncateValue) {
results[index++] = Eigen::half(f[1]);
if (index >= kResultElementCount) {
return results;
}
}
}
}
};
template <class SingleSampleGenerator>
class TruncatedNormalDistribution<SingleSampleGenerator, bfloat16> {
public:
static constexpr int kResultElementCount =
SingleSampleGenerator::kNativeElementCount;
static constexpr int kElementCost = 90;
static constexpr bool kVariableSamplesPerOutput = true;
const float kTruncateValue = 2.0f;
typedef Array<bfloat16, kResultElementCount> ResultType;
typedef bfloat16 ResultElementType;
PHILOX_DEVICE_INLINE
ResultType operator()(SingleSampleGenerator* gen) {
ResultType results;
int index = 0;
while (true) {
const uint32 x0 = (*gen)();
const uint32 x1 = (*gen)();
float f[2];
BoxMullerFloat(x0, x1, &f[0], &f[1]);
if (Eigen::numext::abs(f[0]) < kTruncateValue) {
results[index++] = bfloat16(f[0]);
if (index >= kResultElementCount) {
return results;
}
}
if (Eigen::numext::abs(f[1]) < kTruncateValue) {
results[index++] = bfloat16(f[1]);
if (index >= kResultElementCount) {
return results;
}
}
}
}
};
template <class SingleSampleGenerator>
class TruncatedNormalDistribution<SingleSampleGenerator, float> {
public:
static constexpr int kResultElementCount =
SingleSampleGenerator::kNativeElementCount;
static constexpr int kElementCost = 90;
static constexpr bool kVariableSamplesPerOutput = true;
const float kTruncateValue = 2.0f;
typedef Array<float, kResultElementCount> ResultType;
typedef float ResultElementType;
PHILOX_DEVICE_INLINE
ResultType operator()(SingleSampleGenerator* gen) {
ResultType results;
int index = 0;
while (true) {
const uint32 x0 = (*gen)();
const uint32 x1 = (*gen)();
float f[2];
BoxMullerFloat(x0, x1, &f[0], &f[1]);
if (Eigen::numext::abs(f[0]) < kTruncateValue) {
results[index++] = f[0];
if (index >= kResultElementCount) {
return results;
}
}
if (Eigen::numext::abs(f[1]) < kTruncateValue) {
results[index++] = f[1];
if (index >= kResultElementCount) {
return results;
}
}
}
}
};
template <class SingleSampleGenerator>
class TruncatedNormalDistribution<SingleSampleGenerator, double> {
public:
static constexpr int kResultElementCount =
(SingleSampleGenerator::kNativeElementCount > 1)
? SingleSampleGenerator::kNativeElementCount / 2
: 1;
static constexpr int kElementCost = 90;
static constexpr bool kVariableSamplesPerOutput = true;
typedef Array<double, kResultElementCount> ResultType;
typedef double ResultElementType;
const double kTruncateValue = 2.0;
PHILOX_DEVICE_INLINE
ResultType operator()(SingleSampleGenerator* gen) {
ResultType results;
int index = 0;
while (true) {
const uint32 x0 = (*gen)();
const uint32 x1 = (*gen)();
const uint32 x2 = (*gen)();
const uint32 x3 = (*gen)();
double d[2];
BoxMullerDouble(x0, x1, x2, x3, &d[0], &d[1]);
if (Eigen::numext::abs(d[0]) < kTruncateValue) {
results[index++] = d[0];
if (index >= kResultElementCount) {
return results;
}
}
if (Eigen::numext::abs(d[1]) < kTruncateValue) {
results[index++] = d[1];
if (index >= kResultElementCount) {
return results;
}
}
}
}
};
PHILOX_DEVICE_INLINE
void BoxMullerDouble(uint32 x0, uint32 x1, uint32 x2, uint32 x3, double* d0,
double* d1) {
const double epsilon = 1.0e-7;
double u1 = Uint64ToDouble(x0, x1);
if (u1 < epsilon) {
u1 = epsilon;
}
const double v1 = 2 * M_PI * Uint64ToDouble(x2, x3);
const double u2 = Eigen::numext::sqrt(-2.0 * Eigen::numext::log(u1));
#if !defined(__linux__)
*d0 = Eigen::numext::sin(v1);
*d1 = Eigen::numext::cos(v1);
#else
sincos(v1, d0, d1);
#endif
*d0 *= u2;
*d1 *= u2;
}
PHILOX_DEVICE_INLINE Eigen::half Uint16ToHalf(uint16 x) {
const uint16 man = x & 0x3ffu;
const uint16 exp = static_cast<uint16>(15);
const uint16 val = (exp << 10) | man;
Eigen::half result = Eigen::numext::bit_cast<Eigen::half>(val);
return result - Eigen::half(1.0);
}
PHILOX_DEVICE_INLINE bfloat16 Uint16ToGfloat16(uint16 x) {
const uint16 man = x & 0x7fu;
const uint16 exp = static_cast<uint16>(127);
const uint16 val = (exp << 7) | man;
bfloat16 result;
memcpy(&result, &val, sizeof(val));
return result - bfloat16(1.0);
}
}
}
#endif
#include "tsl/lib/random/distribution_sampler.h"
#include "tsl/lib/random/philox_random.h"
namespace tsl {
namespace random {
template <>
void SingleSampleAdapter<PhiloxRandom>::SkipFromGenerator(uint64 num_skips) {
generator_->Skip(num_skips);
}
}
} | #include "tsl/lib/random/random_distributions.h"
#include <algorithm>
#include <cmath>
#include <functional>
#include <numeric>
#include <unordered_map>
#include <vector>
#include "tsl/lib/math/math_util.h"
#include "tsl/lib/random/philox_random.h"
#include "tsl/lib/random/philox_random_test_utils.h"
#include "tsl/platform/logging.h"
#include "tsl/platform/random.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace random {
namespace {
static constexpr float kZLimit = 6.0;
static constexpr float kZLimitBfloat16 = 20.0;
template <class Distribution>
void FillRandomsWithSingles(PhiloxRandom gen,
typename Distribution::ResultElementType* p,
int64_t size) {
int granularity = Distribution::kResultElementCount;
CHECK(size % granularity == 0)
<< " size: " << size << " granularity: " << granularity;
SingleSampleAdapter<PhiloxRandom> single_samples(&gen);
Distribution dist;
for (int i = 0; i < size; i += granularity) {
auto sample = dist(&single_samples);
std::copy(&sample[0], &sample[0] + granularity, &p[i]);
}
}
template <typename T>
bool CheckSamplesMoments(const std::vector<T>& samples,
const std::function<double(int)>& theoretical_moments,
int max_moments, int stride, T z_limit) {
const T* const samples_data = &samples[0];
const int samples_size = samples.size();
std::vector<double> moments(max_moments + 1);
double* const moments_data = &moments[0];
std::vector<int> moments_sample_count(max_moments + 1);
int* const moments_sample_count_data = &moments_sample_count[0];
for (int k = 0; k < samples_size; ++k) {
double moment = 1.;
for (int i = 0; i <= max_moments; ++i) {
int index = k + i * stride;
if (index >= samples_size) {
break;
}
moments_data[i] += moment;
++moments_sample_count_data[i];
moment *= static_cast<double>(samples_data[index]);
}
}
for (int i = 0; i <= max_moments; ++i) {
moments[i] /= moments_sample_count[i];
}
bool status = true;
for (int i = 1; i <= max_moments; ++i) {
const double moments_i_mean =
(stride == 0) ? theoretical_moments(i)
: MathUtil::IPow(theoretical_moments(1), i);
const double moments_i_squared =
(stride == 0) ? theoretical_moments(2 * i)
: MathUtil::IPow(theoretical_moments(2), i);
const double moments_i_var =
moments_i_squared - moments_i_mean * moments_i_mean;
static const double kNumericalError = 1e-6;
const double error_per_moment = i * kNumericalError;
const double total_variance =
moments_i_var / moments_sample_count[i] + error_per_moment;
const double z_test =
fabs((moments[i] - moments_i_mean) / sqrt(total_variance));
if (z_test > static_cast<double>(z_limit)) {
LOG(ERROR) << "failing z_test:"
<< " moment: " << i << " stride: " << stride
<< " z_test: " << z_test << " z_limit: " << z_limit
<< " measured moments: " << moments[i]
<< " theoretical mean of the moments: " << moments_i_mean
<< " theoretical var of the moments: " << moments_i_var
<< " sample count: " << moments_sample_count[i];
status = false;
}
}
return status;
}
template <typename T>
void UniformMomentsTest(int count, int max_moments,
const std::vector<int>& strides, T z_limit) {
auto uniform_moments = [](int n) -> double { return 1. / (n + 1); };
std::vector<T> v1(count);
uint64 seed = GetTestSeed();
PhiloxRandom gen(seed);
FillRandoms<UniformDistribution<PhiloxRandom, T> >(gen, &v1[0], v1.size());
for (int stride : strides) {
bool status =
CheckSamplesMoments(v1, uniform_moments, max_moments, stride, z_limit);
ASSERT_TRUE(status) << " UniformMomentsTest failing. seed: " << seed;
}
}
template <typename T>
void NormalMomentsTest(int count, int max_moments,
const std::vector<int>& strides, T z_limit) {
auto normal_moments = [](int n) -> double {
if (n % 2 == 1) {
return 0.;
} else {
double v = 1.;
for (int i = n - 1; i >= 1; i -= 2) {
v *= i;
}
return v;
}
};
std::vector<T> v1(count);
uint64 seed = GetTestSeed();
PhiloxRandom gen(seed);
FillRandoms<NormalDistribution<PhiloxRandom, T> >(gen, &v1[0], v1.size());
for (int stride : strides) {
bool status =
CheckSamplesMoments(v1, normal_moments, max_moments, stride, z_limit);
ASSERT_TRUE(status) << " NormalMomentsTest failing. seed: " << seed;
}
}
class TruncatedNormalMoments {
public:
double operator()(int n) {
if (n == 0) {
return 1;
}
if (n % 2 == 1) {
return 0.;
}
auto iter = cached_results_.find(n);
if (iter != cached_results_.end()) {
return iter->second;
}
double bias = 2.0 * MathUtil::IPow(kV, n - 1) * kFV / (2.0 * kPhiV - 1.0);
double moment_n_minus_2 = (*this)(n - 2);
double moment_n = (n - 1) * moment_n_minus_2 - bias;
cached_results_[n] = moment_n;
return moment_n;
}
private:
const double kV = 2.0;
const double kFV = 1.0 / sqrt(2.0 * M_PI) * exp(-kV * kV / 2.0);
const double kPhiV = 0.977249868051821;
std::unordered_map<int, double> cached_results_;
};
template <typename T>
void RandomParametersMomentsTest(int count, int max_moments,
const std::vector<int>& strides, T z_limit) {
std::vector<T> v1(count);
uint64 seed = GetTestSeed();
PhiloxRandom gen(seed);
FillRandomsWithSingles<
TruncatedNormalDistribution<SingleSampleAdapter<PhiloxRandom>, T> >(
gen, &v1[0], v1.size());
for (int stride : strides) {
bool status = CheckSamplesMoments(v1, TruncatedNormalMoments(), max_moments,
stride, z_limit);
ASSERT_TRUE(status) << " NormalMomentsTest failing. seed: " << seed;
}
}
TEST(PhiloxRandomTest, UniformBfloat16MomentsTest) {
const std::vector<int> strides = {0, 1, 4, 17};
UniformMomentsTest<bfloat16>(1 << 20, 40, strides, bfloat16(kZLimitBfloat16));
}
TEST(PhiloxRandomTest, NormalBfloat16MomentsTest) {
const std::vector<int> strides = {0, 1, 4, 17};
NormalMomentsTest<bfloat16>(8 << 20, 25, strides, bfloat16(kZLimitBfloat16));
}
TEST(PhiloxRandomTest, RandomParametersBfloat16MomentsTest) {
const std::vector<int> strides = {0, 1, 4, 17};
RandomParametersMomentsTest<bfloat16>(1 << 20, 40, strides,
bfloat16(kZLimitBfloat16));
}
TEST(PhiloxRandomTest, UniformFloatMomentsTest) {
const std::vector<int> strides = {0, 1, 4, 17};
UniformMomentsTest<float>(1 << 20, 40, strides, kZLimit);
}
TEST(PhiloxRandomTest, NormalFloatMomentsTest) {
const std::vector<int> strides = {0, 1, 4, 17};
NormalMomentsTest<float>(8 << 20, 25, strides, kZLimit);
}
TEST(PhiloxRandomTest, RandomParametersFloatMomentsTest) {
const std::vector<int> strides = {0, 1, 4, 17};
RandomParametersMomentsTest<float>(1 << 20, 40, strides, kZLimit);
}
TEST(PhiloxRandomTest, UniformDoubleMomentsTest) {
const std::vector<int> strides = {0, 1, 4, 17};
UniformMomentsTest<double>(1 << 20, 40, strides, kZLimit);
}
TEST(PhiloxRandomTest, NormalDoubleMomentsTest) {
const std::vector<int> strides = {0, 1, 4, 17};
NormalMomentsTest<double>(8 << 20, 25, strides, kZLimit);
}
TEST(PhiloxRandomTest, RandomParametersDoubleMomentsTest) {
const std::vector<int> strides = {0, 1, 4, 17};
RandomParametersMomentsTest<double>(1 << 20, 40, strides, kZLimit);
}
class MockGenerator {
public:
explicit MockGenerator(uint64 seed) : counter_(seed) {}
using ResultType = std::vector<uint32>;
using ResultElementType = uint32;
static constexpr int kResultElementCount = 1;
ResultType operator()() {
ResultType result;
result.push_back(counter_++);
return result;
}
private:
uint32 counter_;
};
template <typename T>
void SingleSampleAdapterSkipTest() {
std::vector<uint64> skips(10);
std::vector<uint64> skip_afters(10);
std::iota(skips.begin(), skips.end(), 0);
std::iota(skip_afters.begin(), skip_afters.end(), 0);
uint64 total_samples = 100;
uint64 seed = GetTestSeed();
for (uint64 skip : skips) {
for (uint64 skip_after : skip_afters) {
T parent_gen(seed);
SingleSampleAdapter<T> gen(&parent_gen);
T parent_gen_to_skip(seed);
SingleSampleAdapter<T> gen_to_skip(&parent_gen_to_skip);
int cur = 0;
for (; cur < skip_after; cur++) {
gen();
gen_to_skip();
}
for (; cur < skip_after + skip; cur++) {
gen();
}
gen_to_skip.Skip(skip);
for (; cur < total_samples; cur++) {
ASSERT_EQ(gen(), gen_to_skip());
}
}
}
}
TEST(SingleSampleAdapterTest, PhiloxRandomSkip) {
SingleSampleAdapterSkipTest<PhiloxRandom>();
}
TEST(SingleSampleAdapterTest, MockGeneratorSkip) {
SingleSampleAdapterSkipTest<MockGenerator>();
}
}
}
} |
2,642 | cpp | google/tsl | distribution_sampler | tsl/lib/random/distribution_sampler.cc | tsl/lib/random/distribution_sampler_test.cc | #ifndef TENSORFLOW_TSL_LIB_RANDOM_DISTRIBUTION_SAMPLER_H_
#define TENSORFLOW_TSL_LIB_RANDOM_DISTRIBUTION_SAMPLER_H_
#include <memory>
#include <utility>
#include "absl/types/span.h"
#include "tsl/lib/random/simple_philox.h"
#include "tsl/platform/logging.h"
#include "tsl/platform/macros.h"
#include "tsl/platform/types.h"
namespace tsl {
namespace random {
class DistributionSampler {
public:
explicit DistributionSampler(const absl::Span<const float> weights);
~DistributionSampler() {}
int Sample(SimplePhilox* rand) const {
float r = rand->RandFloat();
int idx = rand->Uniform(num_);
if (r < prob(idx)) return idx;
DCHECK_NE(-1, alt(idx));
return alt(idx);
}
int num() const { return num_; }
private:
float prob(int idx) const {
DCHECK_LT(idx, num_);
return data_[idx].first;
}
int alt(int idx) const {
DCHECK_LT(idx, num_);
return data_[idx].second;
}
void set_prob(int idx, float f) {
DCHECK_LT(idx, num_);
data_[idx].first = f;
}
void set_alt(int idx, int val) {
DCHECK_LT(idx, num_);
data_[idx].second = val;
}
int num_;
std::unique_ptr<std::pair<float, int>[]> data_;
DistributionSampler(const DistributionSampler&) = delete;
void operator=(const DistributionSampler&) = delete;
};
}
}
#endif
#include "tsl/lib/random/distribution_sampler.h"
#include <memory>
#include <vector>
#include "absl/types/span.h"
namespace tsl {
namespace random {
DistributionSampler::DistributionSampler(
const absl::Span<const float> weights) {
DCHECK(!weights.empty());
int n = weights.size();
num_ = n;
data_.reset(new std::pair<float, int>[n]);
std::unique_ptr<double[]> pr(new double[n]);
double sum = 0.0;
for (int i = 0; i < n; i++) {
sum += weights[i];
set_alt(i, -1);
}
std::vector<int> high;
high.reserve(n);
std::vector<int> low;
low.reserve(n);
for (int i = 0; i < n; i++) {
double p = (weights[i] * n) / sum;
pr[i] = p;
if (p < 1.0) {
low.push_back(i);
} else {
high.push_back(i);
}
}
while (!high.empty() && !low.empty()) {
int l = low.back();
low.pop_back();
int h = high.back();
high.pop_back();
set_alt(l, h);
DCHECK_GE(pr[h], 1.0);
double remaining = pr[h] - (1.0 - pr[l]);
pr[h] = remaining;
if (remaining < 1.0) {
low.push_back(h);
} else {
high.push_back(h);
}
}
for (int i = 0; i < n; i++) {
set_prob(i, pr[i]);
}
for (size_t i = 0; i < high.size(); i++) {
int idx = high[i];
set_prob(idx, 1.0);
set_alt(idx, idx);
}
for (size_t i = 0; i < low.size(); i++) {
int idx = low[i];
set_prob(idx, 1.0);
set_alt(idx, idx);
}
}
}
} | #include "tsl/lib/random/distribution_sampler.h"
#include <string.h>
#include <memory>
#include <vector>
#include "tsl/lib/random/simple_philox.h"
#include "tsl/platform/macros.h"
#include "tsl/platform/test.h"
#include "tsl/platform/test_benchmark.h"
#include "tsl/platform/types.h"
namespace tsl {
namespace random {
class DistributionSamplerTest : public ::testing::Test {
protected:
float TestWeights(const std::vector<float>& weights, int trials_per_bin) {
int iters = weights.size() * trials_per_bin;
std::unique_ptr<float[]> counts(new float[weights.size()]);
memset(counts.get(), 0, sizeof(float) * weights.size());
DistributionSampler sampler(weights);
PhiloxRandom philox(testing::RandomSeed(), 17);
SimplePhilox random(&philox);
for (int i = 0; i < iters; i++) {
int r = sampler.Sample(&random);
EXPECT_LT(r, weights.size());
EXPECT_GE(r, 0);
counts[r] += 1.0;
}
float chi2 = 0.0;
for (size_t i = 0; i < weights.size(); i++) {
counts[i] /= iters;
float err = (counts[i] - weights[i]);
chi2 += (err * err) / weights[i];
}
return chi2;
}
void TestDistribution(float* arr, int n) {
std::vector<float> w;
w.reserve(n);
for (int i = 0; i < n; i++) {
w.push_back(arr[i]);
}
float var = TestWeights(w, 1000);
if (var < 0.001) return;
var = TestWeights(w, 100000);
if (var < 0.001) return;
EXPECT_TRUE(false) << "Chi2 is " << var << " in " << n * 100000
<< "iterations";
}
};
TEST_F(DistributionSamplerTest, KnownDistribution) {
float kEven2[] = {0.5, 0.5};
float kEven3[] = {0.33333333, 0.33333333, 0.33333333};
float kEven4[] = {0.25, 0.25, 0.25, 0.25};
float kDist1[] = {0.8, 0.15, 0.05};
TestDistribution(kEven2, TF_ARRAYSIZE(kEven2));
TestDistribution(kEven3, TF_ARRAYSIZE(kEven3));
TestDistribution(kEven4, TF_ARRAYSIZE(kEven4));
TestDistribution(kDist1, TF_ARRAYSIZE(kDist1));
}
static void BM_DistributionSampler(::testing::benchmark::State& state) {
const int n = state.range(0);
PhiloxRandom philox(173, 371);
SimplePhilox rand(&philox);
std::vector<float> weights(n, 0);
for (int i = 0; i < n; i++) {
weights[i] = rand.Uniform(100);
}
DistributionSampler picker(weights);
int r = 0;
for (auto s : state) {
r |= picker.Sample(&rand);
}
CHECK_NE(r, kint32max);
}
BENCHMARK(BM_DistributionSampler)->Arg(10)->Arg(100)->Arg(1000);
}
} |
2,643 | cpp | google/tsl | simple_philox | tsl/lib/random/simple_philox.cc | tsl/lib/random/simple_philox_test.cc | #ifndef TENSORFLOW_TSL_LIB_RANDOM_SIMPLE_PHILOX_H_
#define TENSORFLOW_TSL_LIB_RANDOM_SIMPLE_PHILOX_H_
#include <math.h>
#include <string.h>
#include <algorithm>
#include "tsl/lib/random/philox_random.h"
#include "tsl/lib/random/random_distributions.h"
namespace tsl {
namespace random {
class SimplePhilox {
public:
PHILOX_DEVICE_INLINE
explicit SimplePhilox(PhiloxRandom* gen) : single_(gen) {}
PHILOX_DEVICE_INLINE uint32 Rand32() { return single_(); }
PHILOX_DEVICE_INLINE uint64 Rand64() {
const uint32 lo = single_(), hi = single_();
return lo | static_cast<uint64>(hi) << 32;
}
PHILOX_DEVICE_INLINE float RandFloat() { return Uint32ToFloat(single_()); }
PHILOX_DEVICE_INLINE double RandDouble() {
const uint32 x0 = single_(), x1 = single_();
return Uint64ToDouble(x0, x1);
}
uint32 Uniform(uint32 n);
uint64 Uniform64(uint64 n);
bool OneIn(uint32 n) { return Uniform(n) == 0; }
uint32 Skewed(int max_log);
private:
SingleSampleAdapter<PhiloxRandom> single_;
};
}
}
#endif
#include "tsl/lib/random/simple_philox.h"
#include "tsl/lib/random/exact_uniform_int.h"
#include "tsl/platform/logging.h"
namespace tsl {
namespace random {
uint32 SimplePhilox::Uniform(uint32 n) {
return ExactUniformInt<uint32>(n, [this]() { return Rand32(); });
}
uint64 SimplePhilox::Uniform64(uint64 n) {
return ExactUniformInt<uint64>(n, [this]() { return Rand64(); });
}
uint32 SimplePhilox::Skewed(int max_log) {
CHECK(0 <= max_log && max_log <= 32);
const int shift = Rand32() % (max_log + 1);
const uint32 mask = shift == 32 ? ~static_cast<uint32>(0) : (1 << shift) - 1;
return Rand32() & mask;
}
}
} | #include "tsl/lib/random/simple_philox.h"
#include <set>
#include <string>
#include "tsl/platform/logging.h"
#include "tsl/platform/test.h"
#include "tsl/platform/types.h"
namespace tsl {
namespace random {
namespace {
TEST(SimplePhiloxTest, FloatTest) {
PhiloxRandom philox(7, 7);
SimplePhilox gen(&philox);
static const int kIters = 1000000;
for (int i = 0; i < kIters; ++i) {
float f = gen.RandFloat();
EXPECT_LE(0.0f, f);
EXPECT_GT(1.0f, f);
}
for (int i = 0; i < kIters; ++i) {
double d = gen.RandDouble();
EXPECT_LE(0.0, d);
EXPECT_GT(1.0, d);
}
}
static void DifferenceTest(const char *names, SimplePhilox *gen1,
SimplePhilox *gen2) {
static const int kIters = 100;
bool different = false;
for (int i = 0; i < kIters; ++i) {
if (gen1->Rand32() != gen2->Rand32()) {
different = true;
break;
}
}
CHECK(different) << "different seeds but same output!";
}
TEST(SimplePhiloxTest, DifferenceTest) {
PhiloxRandom philox1(1, 1), philox2(17, 17);
SimplePhilox gen1(&philox1), gen2(&philox2);
DifferenceTest("SimplePhilox: different seeds", &gen1, &gen2);
}
TEST(SimplePhiloxTest, DifferenceTestCloseSeeds) {
PhiloxRandom philox1(1, 1), philox2(2, 1);
SimplePhilox gen1(&philox1), gen2(&philox2);
DifferenceTest("SimplePhilox: close seeds", &gen1, &gen2);
}
TEST(SimplePhiloxTest, Regression_CloseSeedsAreDifferent) {
const int kCount = 1000;
PhiloxRandom philox1(0, 1), philox2(1, 1);
SimplePhilox gen1(&philox1), gen2(&philox2);
std::set<uint32> first;
std::set<uint32> all;
for (int i = 0; i < kCount; ++i) {
uint32 v = gen1.Rand32();
first.insert(v);
all.insert(v);
all.insert(gen2.Rand32());
}
EXPECT_EQ(kCount, first.size());
EXPECT_EQ(2 * kCount, all.size());
}
TEST(SimplePhiloxTest, TestUniform) {
PhiloxRandom philox(17, 17);
SimplePhilox gen(&philox);
uint32 range = 3 * (1L << 29);
uint32 threshold = 1L << 30;
size_t count = 0;
static const int kTrials = 100000;
for (int i = 0; i < kTrials; ++i) {
uint32 rnd = gen.Uniform(range);
if (rnd < threshold) {
++count;
}
}
EXPECT_LT(fabs((threshold + 0.0) / range - (count + 0.0) / kTrials), 0.005);
}
TEST(SimplePhiloxTest, TestUniform64) {
PhiloxRandom philox(17, 17);
SimplePhilox gen(&philox);
uint64 range = 3 * (1LL << 59);
uint64 threshold = 1LL << 60;
size_t count = 0;
static const int kTrials = 100000;
for (int i = 0; i < kTrials; ++i) {
uint64 rnd = gen.Uniform64(range);
if (rnd < threshold) {
++count;
}
}
EXPECT_LT(fabs((threshold + 0.0) / range - (count + 0.0) / kTrials), 0.005);
}
}
}
} |
2,644 | cpp | google/tsl | histogram | null | null | #ifndef TENSORFLOW_TSL_LIB_HISTOGRAM_HISTOGRAM_H_
#define TENSORFLOW_TSL_LIB_HISTOGRAM_HISTOGRAM_H_
#include <string>
#include <vector>
#include "tsl/platform/macros.h"
#include "tsl/platform/mutex.h"
#include "tsl/platform/thread_annotations.h"
#include "tsl/platform/types.h"
namespace tensorflow {
class HistogramProto;
}
namespace tsl {
using tensorflow::HistogramProto;
namespace histogram {
class Histogram {
public:
Histogram();
explicit Histogram(absl::Span<const double> custom_bucket_limits);
bool DecodeFromProto(const HistogramProto& proto);
~Histogram() {}
void Clear();
void Add(double value);
void EncodeToProto(HistogramProto* proto, bool preserve_zero_buckets) const;
double Median() const;
double Percentile(double p) const;
double Average() const;
double StandardDeviation() const;
std::string ToString() const;
private:
double min_;
double max_;
double num_;
double sum_;
double sum_squares_;
std::vector<double> custom_bucket_limits_;
absl::Span<const double> bucket_limits_;
std::vector<double> buckets_;
double Remap(double x, double x0, double x1, double y0, double y1) const;
Histogram(const Histogram&) = delete;
void operator=(const Histogram&) = delete;
};
class ThreadSafeHistogram {
public:
ThreadSafeHistogram() {}
explicit ThreadSafeHistogram(absl::Span<const double> custom_bucket_limits)
: histogram_(custom_bucket_limits) {}
bool DecodeFromProto(const HistogramProto& proto);
~ThreadSafeHistogram() {}
void Clear();
void Add(double value);
void EncodeToProto(HistogramProto* proto, bool preserve_zero_buckets) const;
double Median() const;
double Percentile(double p) const;
double Average() const;
double StandardDeviation() const;
std::string ToString() const;
private:
mutable mutex mu_;
Histogram histogram_ TF_GUARDED_BY(mu_);
};
}
}
#endif
#include "tsl/lib/histogram/histogram.h"
#include <float.h>
#include <math.h>
#include <vector>
#include "tsl/platform/logging.h"
#include "tsl/platform/mutex.h"
#include "tsl/platform/types.h"
#include "tsl/protobuf/histogram.pb.h"
namespace tsl {
namespace histogram {
static std::vector<double>* InitDefaultBucketsInner() {
std::vector<double> buckets;
std::vector<double> neg_buckets;
double v = 1.0e-12;
while (v < 1.0e20) {
buckets.push_back(v);
neg_buckets.push_back(-v);
v *= 1.1;
}
buckets.push_back(DBL_MAX);
neg_buckets.push_back(-DBL_MAX);
std::reverse(neg_buckets.begin(), neg_buckets.end());
std::vector<double>* result = new std::vector<double>;
result->insert(result->end(), neg_buckets.begin(), neg_buckets.end());
result->push_back(0.0);
result->insert(result->end(), buckets.begin(), buckets.end());
return result;
}
static absl::Span<const double> InitDefaultBuckets() {
static std::vector<double>* default_bucket_limits = InitDefaultBucketsInner();
return *default_bucket_limits;
}
Histogram::Histogram() : bucket_limits_(InitDefaultBuckets()) { Clear(); }
Histogram::Histogram(absl::Span<const double> custom_bucket_limits)
: custom_bucket_limits_(custom_bucket_limits.begin(),
custom_bucket_limits.end()),
bucket_limits_(custom_bucket_limits_) {
#ifndef NDEBUG
DCHECK_GT(bucket_limits_.size(), size_t{0});
for (size_t i = 1; i < bucket_limits_.size(); i++) {
DCHECK_GT(bucket_limits_[i], bucket_limits_[i - 1]);
}
#endif
Clear();
}
bool Histogram::DecodeFromProto(const HistogramProto& proto) {
if ((proto.bucket_size() != proto.bucket_limit_size()) ||
(proto.bucket_size() == 0)) {
return false;
}
min_ = proto.min();
max_ = proto.max();
num_ = proto.num();
sum_ = proto.sum();
sum_squares_ = proto.sum_squares();
custom_bucket_limits_.clear();
custom_bucket_limits_.insert(custom_bucket_limits_.end(),
proto.bucket_limit().begin(),
proto.bucket_limit().end());
bucket_limits_ = custom_bucket_limits_;
buckets_.clear();
buckets_.insert(buckets_.end(), proto.bucket().begin(), proto.bucket().end());
return true;
}
void Histogram::Clear() {
min_ = bucket_limits_[bucket_limits_.size() - 1];
max_ = -DBL_MAX;
num_ = 0;
sum_ = 0;
sum_squares_ = 0;
buckets_.resize(bucket_limits_.size());
for (size_t i = 0; i < bucket_limits_.size(); i++) {
buckets_[i] = 0;
}
}
void Histogram::Add(double value) {
int b =
std::upper_bound(bucket_limits_.begin(), bucket_limits_.end(), value) -
bucket_limits_.begin();
buckets_[b] += 1.0;
if (min_ > value) min_ = value;
if (max_ < value) max_ = value;
num_++;
sum_ += value;
sum_squares_ += (value * value);
}
double Histogram::Median() const { return Percentile(50.0); }
double Histogram::Remap(double x, double x0, double x1, double y0,
double y1) const {
return y0 + (x - x0) / (x1 - x0) * (y1 - y0);
}
double Histogram::Percentile(double p) const {
if (num_ == 0.0) return 0.0;
double threshold = num_ * (p / 100.0);
double cumsum_prev = 0;
for (size_t i = 0; i < buckets_.size(); i++) {
double cumsum = cumsum_prev + buckets_[i];
if (cumsum >= threshold) {
if (cumsum == cumsum_prev) {
continue;
}
double lhs = (i == 0 || cumsum_prev == 0) ? min_ : bucket_limits_[i - 1];
lhs = std::max(lhs, min_);
double rhs = bucket_limits_[i];
rhs = std::min(rhs, max_);
double weight = Remap(threshold, cumsum_prev, cumsum, lhs, rhs);
return weight;
}
cumsum_prev = cumsum;
}
return max_;
}
double Histogram::Average() const {
if (num_ == 0.0) return 0;
return sum_ / num_;
}
double Histogram::StandardDeviation() const {
if (num_ == 0.0) return 0;
double variance = (sum_squares_ * num_ - sum_ * sum_) / (num_ * num_);
return sqrt(variance);
}
std::string Histogram::ToString() const {
std::string r;
char buf[200];
snprintf(buf, sizeof(buf), "Count: %.0f Average: %.4f StdDev: %.2f\n", num_,
Average(), StandardDeviation());
r.append(buf);
snprintf(buf, sizeof(buf), "Min: %.4f Median: %.4f Max: %.4f\n",
(num_ == 0.0 ? 0.0 : min_), Median(), max_);
r.append(buf);
r.append("------------------------------------------------------\n");
const double mult = num_ > 0 ? 100.0 / num_ : 0.0;
double sum = 0;
for (size_t b = 0; b < buckets_.size(); b++) {
if (buckets_[b] <= 0.0) continue;
sum += buckets_[b];
snprintf(buf, sizeof(buf), "[ %10.2g, %10.2g ) %7.0f %7.3f%% %7.3f%% ",
((b == 0) ? -DBL_MAX : bucket_limits_[b - 1]),
bucket_limits_[b],
buckets_[b],
mult * buckets_[b],
mult * sum);
r.append(buf);
int marks = static_cast<int>(20 * (buckets_[b] / num_) + 0.5);
r.append(marks, '#');
r.push_back('\n');
}
return r;
}
void Histogram::EncodeToProto(HistogramProto* proto,
bool preserve_zero_buckets) const {
proto->Clear();
proto->set_min(min_);
proto->set_max(max_);
proto->set_num(num_);
proto->set_sum(sum_);
proto->set_sum_squares(sum_squares_);
for (size_t i = 0; i < buckets_.size();) {
double end = bucket_limits_[i];
double count = buckets_[i];
i++;
if (!preserve_zero_buckets && count <= 0.0) {
while (i < buckets_.size() && buckets_[i] <= 0.0) {
end = bucket_limits_[i];
count = buckets_[i];
i++;
}
}
proto->add_bucket_limit(end);
proto->add_bucket(count);
}
if (proto->bucket_size() == 0.0) {
proto->add_bucket_limit(DBL_MAX);
proto->add_bucket(0.0);
}
}
bool ThreadSafeHistogram::DecodeFromProto(const HistogramProto& proto) {
mutex_lock l(mu_);
return histogram_.DecodeFromProto(proto);
}
void ThreadSafeHistogram::Clear() {
mutex_lock l(mu_);
histogram_.Clear();
}
void ThreadSafeHistogram::Add(double value) {
mutex_lock l(mu_);
histogram_.Add(value);
}
void ThreadSafeHistogram::EncodeToProto(HistogramProto* proto,
bool preserve_zero_buckets) const {
mutex_lock l(mu_);
histogram_.EncodeToProto(proto, preserve_zero_buckets);
}
double ThreadSafeHistogram::Median() const {
mutex_lock l(mu_);
return histogram_.Median();
}
double ThreadSafeHistogram::Percentile(double p) const {
mutex_lock l(mu_);
return histogram_.Percentile(p);
}
double ThreadSafeHistogram::Average() const {
mutex_lock l(mu_);
return histogram_.Average();
}
double ThreadSafeHistogram::StandardDeviation() const {
mutex_lock l(mu_);
return histogram_.StandardDeviation();
}
std::string ThreadSafeHistogram::ToString() const {
mutex_lock l(mu_);
return histogram_.ToString();
}
}
} | #include "tsl/lib/histogram/histogram.h"
#include <float.h>
#include "tsl/platform/logging.h"
#include "tsl/platform/test.h"
#include "tsl/protobuf/histogram.pb.h"
namespace tsl {
namespace histogram {
static void Validate(const Histogram& h) {
string s1 = h.ToString();
LOG(ERROR) << s1;
HistogramProto proto_with_zeroes;
h.EncodeToProto(&proto_with_zeroes, true);
Histogram h2;
EXPECT_TRUE(h2.DecodeFromProto(proto_with_zeroes));
string s2 = h2.ToString();
LOG(ERROR) << s2;
EXPECT_EQ(s1, s2);
HistogramProto proto_no_zeroes;
h.EncodeToProto(&proto_no_zeroes, false);
LOG(ERROR) << proto_no_zeroes.DebugString();
Histogram h3;
EXPECT_TRUE(h3.DecodeFromProto(proto_no_zeroes));
string s3 = h3.ToString();
LOG(ERROR) << s3;
EXPECT_EQ(s1, s3);
}
TEST(Histogram, Empty) {
Histogram h;
Validate(h);
}
TEST(Histogram, SingleValue) {
Histogram h;
h.Add(-3.0);
Validate(h);
}
TEST(Histogram, CustomBuckets) {
Histogram h({-10, -5, 0, 5, 10, 100, 1000, 10000, DBL_MAX});
h.Add(-3.0);
h.Add(4.99);
h.Add(5.0);
h.Add(1000.0);
Validate(h);
}
TEST(Histogram, Median) {
Histogram h({0, 10, 100, DBL_MAX});
h.Add(-2);
h.Add(-2);
h.Add(0);
double median = h.Median();
EXPECT_EQ(median, -0.5);
}
TEST(Histogram, Percentile) {
Histogram h({1, 2, 3, 4});
h.Add(-1.0);
h.Add(1.5);
h.Add(1.5);
h.Add(1.5);
h.Add(2.5);
h.Add(2.5);
h.Add(2.5);
h.Add(2.5);
h.Add(3.5);
h.Add(3.9);
EXPECT_EQ(h.Percentile(0), -1.0);
EXPECT_EQ(h.Percentile(25), 1.5);
EXPECT_EQ(h.Percentile(50), 2.25);
EXPECT_EQ(h.Percentile(75), 2.875);
EXPECT_EQ(h.Percentile(90), 3.45);
EXPECT_EQ(h.Percentile(100), 3.9);
}
TEST(Histogram, Basic) {
Histogram h;
for (int i = 0; i < 100; i++) {
h.Add(i);
}
for (int i = 1000; i < 100000; i += 1000) {
h.Add(i);
}
Validate(h);
}
TEST(ThreadSafeHistogram, Basic) {
Histogram h;
for (int i = 0; i < 100; i++) {
h.Add(i);
}
ThreadSafeHistogram tsh;
for (int i = 0; i < 100; i++) {
tsh.Add(i);
}
for (int i = 0; i < 2; ++i) {
bool preserve_zero_buckets = (i == 0);
HistogramProto h_proto;
h.EncodeToProto(&h_proto, preserve_zero_buckets);
HistogramProto tsh_proto;
tsh.EncodeToProto(&tsh_proto, preserve_zero_buckets);
Histogram h2;
EXPECT_TRUE(h2.DecodeFromProto(tsh_proto));
ThreadSafeHistogram tsh2;
EXPECT_TRUE(tsh2.DecodeFromProto(h_proto));
EXPECT_EQ(h2.ToString(), tsh2.ToString());
}
EXPECT_EQ(h.Median(), tsh.Median());
EXPECT_EQ(h.Percentile(40.0), tsh.Percentile(40.0));
EXPECT_EQ(h.Average(), tsh.Average());
EXPECT_EQ(h.StandardDeviation(), tsh.StandardDeviation());
EXPECT_EQ(h.ToString(), tsh.ToString());
}
}
} |
2,645 | cpp | google/tsl | crc32c | tsl/lib/hash/crc32c.cc | tsl/lib/hash/crc32c_test.cc | #ifndef TENSORFLOW_TSL_LIB_HASH_CRC32C_H_
#define TENSORFLOW_TSL_LIB_HASH_CRC32C_H_
#include <stddef.h>
#include "absl/crc/crc32c.h"
#include "absl/strings/string_view.h"
#include "tsl/platform/cord.h"
#include "tsl/platform/platform.h"
#include "tsl/platform/types.h"
namespace tsl {
namespace crc32c {
inline uint32 Extend(uint32 init_crc, const char* buf, size_t size) {
return static_cast<uint32>(absl::ExtendCrc32c(
static_cast<absl::crc32c_t>(init_crc), absl::string_view(buf, size)));
}
#if defined(TF_CORD_SUPPORT)
extern uint32 Extend(uint32 init_crc, const absl::Cord& cord);
#endif
inline uint32 Value(const char* data, size_t n) { return Extend(0, data, n); }
#if defined(TF_CORD_SUPPORT)
inline uint32 Value(const absl::Cord& cord) { return Extend(0, cord); }
#endif
static const uint32 kMaskDelta = 0xa282ead8ul;
inline uint32 Mask(uint32 crc) {
return ((crc >> 15) | (crc << 17)) + kMaskDelta;
}
inline uint32 Unmask(uint32 masked_crc) {
uint32 rot = masked_crc - kMaskDelta;
return ((rot >> 17) | (rot << 15));
}
}
}
#endif
#include "tsl/lib/hash/crc32c.h"
#include <stdint.h>
#include "absl/strings/cord.h"
#include "absl/strings/string_view.h"
#include "tsl/platform/types.h"
namespace tsl {
namespace crc32c {
#if defined(TF_CORD_SUPPORT)
uint32 Extend(uint32 crc, const absl::Cord &cord) {
for (absl::string_view fragment : cord.Chunks()) {
crc = Extend(crc, fragment.data(), fragment.size());
}
return crc;
}
#endif
}
} | #include "tsl/lib/hash/crc32c.h"
#include <string>
#include "absl/strings/cord.h"
#include "tsl/platform/logging.h"
#include "tsl/platform/test.h"
#include "tsl/platform/test_benchmark.h"
#include "tsl/platform/types.h"
namespace tsl {
namespace crc32c {
TEST(CRC, StandardResults) {
char buf[32];
memset(buf, 0, sizeof(buf));
ASSERT_EQ(0x8a9136aa, Value(buf, sizeof(buf)));
memset(buf, 0xff, sizeof(buf));
ASSERT_EQ(0x62a8ab43, Value(buf, sizeof(buf)));
for (int i = 0; i < 32; i++) {
buf[i] = i;
}
ASSERT_EQ(0x46dd794e, Value(buf, sizeof(buf)));
for (int i = 0; i < 32; i++) {
buf[i] = 31 - i;
}
ASSERT_EQ(0x113fdb5c, Value(buf, sizeof(buf)));
unsigned char data[48] = {
0x01, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x18, 0x28, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
ASSERT_EQ(0xd9963a56, Value(reinterpret_cast<char*>(data), sizeof(data)));
ASSERT_EQ(0xdd1b19be, Value(reinterpret_cast<char*>(data), sizeof(data) - 7));
ASSERT_EQ(0x4930c4b1,
Value(reinterpret_cast<char*>(data) + 1, sizeof(data) - 4));
}
TEST(CRC, Values) { ASSERT_NE(Value("a", 1), Value("foo", 3)); }
TEST(CRC, Extend) {
ASSERT_EQ(Value("hello world", 11), Extend(Value("hello ", 6), "world", 5));
}
TEST(CRC, Mask) {
uint32 crc = Value("foo", 3);
ASSERT_NE(crc, Mask(crc));
ASSERT_NE(crc, Mask(Mask(crc)));
ASSERT_EQ(crc, Unmask(Mask(crc)));
ASSERT_EQ(crc, Unmask(Unmask(Mask(Mask(crc)))));
}
#if defined(PLATFORM_GOOGLE)
TEST(CRC, ValuesWithCord) {
ASSERT_NE(Value(absl::Cord("a")), Value(absl::Cord("foo")));
}
TEST(CRC, ExtendWithCord) {
ASSERT_EQ(Value(absl::Cord("hello world")),
Extend(Value(absl::Cord("hello ")), absl::Cord("world")));
}
#endif
static void BM_CRC(::testing::benchmark::State& state) {
int len = state.range(0);
std::string input(len, 'x');
uint32 h = 0;
for (auto s : state) {
h = Extend(h, input.data() + 1, len - 1);
}
state.SetBytesProcessed(state.iterations() * len);
VLOG(1) << h;
}
BENCHMARK(BM_CRC)->Range(1, 256 * 1024);
}
} |
2,646 | cpp | google/tsl | bitmap | null | null | #ifndef TENSORFLOW_TSL_LIB_CORE_BITMAP_H_
#define TENSORFLOW_TSL_LIB_CORE_BITMAP_H_
#include <string>
#include "tsl/platform/logging.h"
namespace tsl {
namespace core {
class Bitmap {
public:
Bitmap();
explicit Bitmap(size_t n);
~Bitmap();
Bitmap(const Bitmap&) = delete;
Bitmap& operator=(const Bitmap&) = delete;
size_t bits() const;
void Reset(size_t n);
bool get(size_t i) const;
void set(size_t i);
void clear(size_t i);
size_t FirstUnset(size_t start) const;
std::string ToString() const;
private:
typedef uint32_t Word;
static constexpr size_t kBits = 32;
static size_t NumWords(size_t n) { return (n + kBits - 1) / kBits; }
static Word Mask(size_t i) { return 1ull << i; }
size_t nbits_;
Word* word_;
};
inline Bitmap::Bitmap() : nbits_(0), word_(nullptr) {}
inline Bitmap::Bitmap(size_t n) : Bitmap() { Reset(n); }
inline Bitmap::~Bitmap() { delete[] word_; }
inline size_t Bitmap::bits() const { return nbits_; }
inline bool Bitmap::get(size_t i) const {
DCHECK_LT(i, nbits_);
return word_[i / kBits] & Mask(i % kBits);
}
inline void Bitmap::set(size_t i) {
DCHECK_LT(i, nbits_);
word_[i / kBits] |= Mask(i % kBits);
}
inline void Bitmap::clear(size_t i) {
DCHECK_LT(i, nbits_);
word_[i / kBits] &= ~Mask(i % kBits);
}
}
}
#endif
#include "tsl/lib/core/bitmap.h"
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <string>
#include "absl/numeric/bits.h"
namespace tsl {
namespace core {
void Bitmap::Reset(size_t n) {
const size_t num_words = NumWords(n);
if (num_words != NumWords(nbits_)) {
Word* w = new Word[num_words];
delete[] word_;
word_ = w;
}
memset(word_, 0, sizeof(word_[0]) * num_words);
nbits_ = n;
}
static size_t FindFirstSet(uint32_t w) {
return w == 0 ? 0 : absl::countr_zero(w) + 1;
}
size_t Bitmap::FirstUnset(size_t start) const {
if (start >= nbits_) {
return nbits_;
}
size_t mask = (1ull << (start % kBits)) - 1;
const size_t nwords = NumWords(nbits_);
for (size_t i = start / kBits; i < nwords; i++) {
Word word = word_[i] | mask;
mask = 0;
size_t r = FindFirstSet(~word);
if (r) {
size_t result = i * kBits + (r - 1);
if (result > nbits_) result = nbits_;
return result;
}
}
return nbits_;
}
std::string Bitmap::ToString() const {
std::string result;
result.resize(bits());
for (size_t i = 0; i < nbits_; i++) {
result[i] = get(i) ? '1' : '0';
}
return result;
}
}
} | #include "tsl/lib/core/bitmap.h"
#include "tsl/lib/random/simple_philox.h"
#include "tsl/platform/macros.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace core {
namespace {
size_t NextSize(size_t n) { return n + ((n < 75) ? 1 : 25); }
static void MakeRandomBitmap(random::SimplePhilox* rnd, Bitmap* bitmap) {
size_t n = rnd->Uniform(200);
bitmap->Reset(n);
for (size_t i = 0; i < n; i++) {
if (rnd->OneIn(2)) bitmap->set(i);
}
}
TEST(BitmapTest, Basic) {
for (size_t n = 0; n < 200; n = NextSize(n)) {
Bitmap bits(n);
for (size_t i = 0; i < n; i++) {
EXPECT_FALSE(bits.get(i)) << n << " " << i << " " << bits.ToString();
bits.set(i);
EXPECT_TRUE(bits.get(i)) << n << " " << i << " " << bits.ToString();
bits.clear(i);
EXPECT_FALSE(bits.get(i)) << n << " " << i << " " << bits.ToString();
}
}
}
TEST(BitmapTest, ToString) {
Bitmap bits(10);
bits.set(1);
bits.set(3);
EXPECT_EQ(bits.ToString(), "0101000000");
}
TEST(BitmapTest, FirstUnset) {
for (size_t n = 0; n < 200; n = NextSize(n)) {
for (size_t p = 0; p <= 100; p++) {
for (size_t q = 0; q <= 100; q++) {
Bitmap bitmap(n);
int one_count = 0;
size_t i = 0;
while (i < p && i < n) {
one_count++;
bitmap.set(i);
i++;
}
while (i < n) {
i++;
for (size_t j = 0; j < q && i < n; j++, i++) {
one_count++;
bitmap.set(i);
}
}
int seen = 0;
size_t pos = 0;
while (true) {
pos = bitmap.FirstUnset(pos);
if (pos == n) break;
ASSERT_FALSE(bitmap.get(pos)) << pos << " " << bitmap.ToString();
seen++;
pos++;
}
EXPECT_EQ(seen, n - one_count) << " " << bitmap.ToString();
}
}
}
}
TEST(BitmapTest, FirstUnsetRandom) {
random::PhiloxRandom philox(301, 17);
random::SimplePhilox rnd(&philox);
for (int iter = 0; iter < 10000; iter++) {
Bitmap bitmap;
MakeRandomBitmap(&rnd, &bitmap);
size_t zero_bits = 0;
for (size_t i = 0; i < bitmap.bits(); i++) {
if (!bitmap.get(i)) zero_bits++;
}
int seen = 0;
size_t pos = 0;
while (true) {
pos = bitmap.FirstUnset(pos);
if (pos == bitmap.bits()) break;
ASSERT_FALSE(bitmap.get(pos)) << pos << " " << bitmap.ToString();
seen++;
pos++;
}
EXPECT_EQ(seen, zero_bits) << " " << bitmap.ToString();
}
}
}
}
} |
2,647 | cpp | google/tsl | table | tsl/lib/io/table.cc | tsl/lib/io/table_test.cc | #ifndef TENSORFLOW_TSL_LIB_IO_TABLE_H_
#define TENSORFLOW_TSL_LIB_IO_TABLE_H_
#include <stdint.h>
#include "tsl/lib/io/iterator.h"
namespace tsl {
class RandomAccessFile;
namespace table {
struct Options;
class Table {
public:
static absl::Status Open(const Options& options, tsl::RandomAccessFile* file,
uint64 file_size, Table** table);
~Table();
Iterator* NewIterator() const;
uint64 ApproximateOffsetOf(const StringPiece& key) const;
private:
struct Rep;
Rep* rep_;
explicit Table(Rep* rep) { rep_ = rep; }
static Iterator* BlockReader(void*, const StringPiece&);
absl::Status InternalGet(const StringPiece& key, void* arg,
void (*handle_result)(void* arg,
const StringPiece& k,
const StringPiece& v));
Table(const Table&);
void operator=(const Table&);
};
}
}
#endif
#include "tsl/lib/io/table.h"
#include "tsl/lib/io/block.h"
#include "tsl/lib/io/cache.h"
#include "tsl/lib/io/format.h"
#include "tsl/lib/io/table_options.h"
#include "tsl/lib/io/two_level_iterator.h"
#include "tsl/platform/coding.h"
#include "tsl/platform/env.h"
#include "tsl/platform/errors.h"
namespace tsl {
namespace table {
struct Table::Rep {
~Rep() { delete index_block; }
Options options;
absl::Status status;
RandomAccessFile* file;
uint64 cache_id;
BlockHandle metaindex_handle;
Block* index_block;
};
absl::Status Table::Open(const Options& options, RandomAccessFile* file,
uint64 size, Table** table) {
*table = nullptr;
if (size < Footer::kEncodedLength) {
return errors::DataLoss("file is too short to be an sstable");
}
char footer_space[Footer::kEncodedLength];
StringPiece footer_input;
absl::Status s =
file->Read(size - Footer::kEncodedLength, Footer::kEncodedLength,
&footer_input, footer_space);
if (!s.ok()) return s;
Footer footer;
s = footer.DecodeFrom(&footer_input);
if (!s.ok()) return s;
BlockContents contents;
Block* index_block = nullptr;
if (s.ok()) {
s = ReadBlock(file, footer.index_handle(), &contents);
}
if (s.ok()) {
index_block = new Block(contents);
Rep* rep = new Table::Rep;
rep->options = options;
rep->file = file;
rep->metaindex_handle = footer.metaindex_handle();
rep->index_block = index_block;
rep->cache_id = (options.block_cache ? options.block_cache->NewId() : 0);
*table = new Table(rep);
} else {
if (index_block) delete index_block;
}
return s;
}
Table::~Table() { delete rep_; }
static void DeleteBlock(void* arg, void* ignored) {
delete reinterpret_cast<Block*>(arg);
}
static void DeleteCachedBlock(const absl::string_view&, void* value) {
Block* block = reinterpret_cast<Block*>(value);
delete block;
}
static void ReleaseBlock(void* arg, void* h) {
Cache* cache = reinterpret_cast<Cache*>(arg);
Cache::Handle* handle = reinterpret_cast<Cache::Handle*>(h);
cache->Release(handle);
}
Iterator* Table::BlockReader(void* arg, const StringPiece& index_value) {
Table* table = reinterpret_cast<Table*>(arg);
Cache* block_cache = table->rep_->options.block_cache;
Block* block = nullptr;
Cache::Handle* cache_handle = nullptr;
BlockHandle handle;
StringPiece input = index_value;
absl::Status s = handle.DecodeFrom(&input);
if (s.ok()) {
BlockContents contents;
if (block_cache != nullptr) {
char cache_key_buffer[16];
core::EncodeFixed64(cache_key_buffer, table->rep_->cache_id);
core::EncodeFixed64(cache_key_buffer + 8, handle.offset());
absl::string_view key(cache_key_buffer, sizeof(cache_key_buffer));
cache_handle = block_cache->Lookup(key);
if (cache_handle != nullptr) {
block = reinterpret_cast<Block*>(block_cache->Value(cache_handle));
} else {
s = ReadBlock(table->rep_->file, handle, &contents);
if (s.ok()) {
block = new Block(contents);
cache_handle = block_cache->Insert(key, block, block->size(),
&DeleteCachedBlock);
}
}
} else {
s = ReadBlock(table->rep_->file, handle, &contents);
if (s.ok()) {
block = new Block(contents);
}
}
}
Iterator* iter;
if (block != nullptr) {
iter = block->NewIterator();
if (cache_handle == nullptr) {
iter->RegisterCleanup(&DeleteBlock, block, nullptr);
} else {
iter->RegisterCleanup(&ReleaseBlock, block_cache, cache_handle);
}
} else {
iter = NewErrorIterator(s);
}
return iter;
}
Iterator* Table::NewIterator() const {
return NewTwoLevelIterator(rep_->index_block->NewIterator(),
&Table::BlockReader, const_cast<Table*>(this));
}
absl::Status Table::InternalGet(const StringPiece& k, void* arg,
void (*saver)(void*, const StringPiece&,
const StringPiece&)) {
absl::Status s;
Iterator* iiter = rep_->index_block->NewIterator();
iiter->Seek(k);
if (iiter->Valid()) {
Iterator* block_iter = BlockReader(this, iiter->value());
block_iter->Seek(k);
if (block_iter->Valid()) {
(*saver)(arg, block_iter->key(), block_iter->value());
}
s = block_iter->status();
delete block_iter;
}
if (s.ok()) {
s = iiter->status();
}
delete iiter;
return s;
}
uint64 Table::ApproximateOffsetOf(const StringPiece& key) const {
Iterator* index_iter = rep_->index_block->NewIterator();
index_iter->Seek(key);
uint64 result;
if (index_iter->Valid()) {
BlockHandle handle;
StringPiece input = index_iter->value();
absl::Status s = handle.DecodeFrom(&input);
if (s.ok()) {
result = handle.offset();
} else {
result = rep_->metaindex_handle.offset();
}
} else {
result = rep_->metaindex_handle.offset();
}
delete index_iter;
return result;
}
}
} | #include "tsl/lib/io/table.h"
#include <algorithm>
#include <map>
#include <string>
#include <vector>
#include "absl/strings/escaping.h"
#include "tsl/lib/io/block.h"
#include "tsl/lib/io/block_builder.h"
#include "tsl/lib/io/format.h"
#include "tsl/lib/io/iterator.h"
#include "tsl/lib/io/table_builder.h"
#include "tsl/lib/random/simple_philox.h"
#include "tsl/platform/env.h"
#include "tsl/platform/errors.h"
#include "tsl/platform/snappy.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace table {
namespace {
typedef std::pair<StringPiece, StringPiece> StringPiecePair;
}
namespace test {
static StringPiece RandomString(random::SimplePhilox* rnd, int len,
string* dst) {
dst->resize(len);
for (int i = 0; i < len; i++) {
(*dst)[i] = static_cast<char>(' ' + rnd->Uniform(95));
}
return StringPiece(*dst);
}
static string RandomKey(random::SimplePhilox* rnd, int len) {
static const char kTestChars[] = {'\0', '\1', 'a', 'b', 'c',
'd', 'e', '\xfd', '\xfe', '\xff'};
string result;
for (int i = 0; i < len; i++) {
result += kTestChars[rnd->Uniform(sizeof(kTestChars))];
}
return result;
}
static StringPiece CompressibleString(random::SimplePhilox* rnd,
double compressed_fraction, size_t len,
string* dst) {
int raw = static_cast<int>(len * compressed_fraction);
if (raw < 1) raw = 1;
string raw_data;
RandomString(rnd, raw, &raw_data);
dst->clear();
while (dst->size() < len) {
dst->append(raw_data);
}
dst->resize(len);
return StringPiece(*dst);
}
}
static void Increment(string* key) { key->push_back('\0'); }
namespace {
struct STLLessThan {
STLLessThan() {}
bool operator()(const string& a, const string& b) const {
return StringPiece(a).compare(StringPiece(b)) < 0;
}
};
}
class StringSink : public WritableFile {
public:
~StringSink() override {}
const string& contents() const { return contents_; }
absl::Status Close() override { return absl::OkStatus(); }
absl::Status Flush() override { return absl::OkStatus(); }
absl::Status Name(StringPiece* result) const override {
return errors::Unimplemented("StringSink does not support Name()");
}
absl::Status Sync() override { return absl::OkStatus(); }
absl::Status Tell(int64_t* pos) override {
*pos = contents_.size();
return absl::OkStatus();
}
absl::Status Append(StringPiece data) override {
contents_.append(data.data(), data.size());
return absl::OkStatus();
}
private:
string contents_;
};
class StringSource : public RandomAccessFile {
public:
explicit StringSource(const StringPiece& contents)
: contents_(contents.data(), contents.size()), bytes_read_(0) {}
~StringSource() override {}
uint64 Size() const { return contents_.size(); }
absl::Status Name(StringPiece* result) const override {
return errors::Unimplemented("StringSource does not support Name()");
}
absl::Status Read(uint64 offset, size_t n, StringPiece* result,
char* scratch) const override {
if (offset > contents_.size()) {
return errors::InvalidArgument("invalid Read offset");
}
if (offset + n > contents_.size()) {
n = contents_.size() - offset;
}
memcpy(scratch, &contents_[offset], n);
*result = StringPiece(scratch, n);
bytes_read_ += n;
return absl::OkStatus();
}
uint64 BytesRead() const { return bytes_read_; }
private:
string contents_;
mutable uint64 bytes_read_;
};
typedef std::map<string, string, STLLessThan> KVMap;
class Constructor {
public:
explicit Constructor() : data_(STLLessThan()) {}
virtual ~Constructor() {}
void Add(const string& key, const StringPiece& value) {
data_[key] = string(value);
}
void Finish(const Options& options, std::vector<string>* keys, KVMap* kvmap) {
*kvmap = data_;
keys->clear();
for (KVMap::const_iterator it = data_.begin(); it != data_.end(); ++it) {
keys->push_back(it->first);
}
data_.clear();
absl::Status s = FinishImpl(options, *kvmap);
ASSERT_TRUE(s.ok()) << s.ToString();
}
virtual absl::Status FinishImpl(const Options& options,
const KVMap& data) = 0;
virtual Iterator* NewIterator() const = 0;
virtual const KVMap& data() { return data_; }
private:
KVMap data_;
};
class BlockConstructor : public Constructor {
public:
BlockConstructor() : block_(nullptr) {}
~BlockConstructor() override { delete block_; }
absl::Status FinishImpl(const Options& options, const KVMap& data) override {
delete block_;
block_ = nullptr;
BlockBuilder builder(&options);
for (KVMap::const_iterator it = data.begin(); it != data.end(); ++it) {
builder.Add(it->first, it->second);
}
data_ = string(builder.Finish());
BlockContents contents;
contents.data = data_;
contents.cacheable = false;
contents.heap_allocated = false;
block_ = new Block(contents);
return absl::OkStatus();
}
Iterator* NewIterator() const override { return block_->NewIterator(); }
private:
string data_;
Block* block_;
};
class TableConstructor : public Constructor {
public:
TableConstructor() : source_(nullptr), table_(nullptr) {}
~TableConstructor() override { Reset(); }
absl::Status FinishImpl(const Options& options, const KVMap& data) override {
Reset();
StringSink sink;
TableBuilder builder(options, &sink);
for (KVMap::const_iterator it = data.begin(); it != data.end(); ++it) {
builder.Add(it->first, it->second);
TF_CHECK_OK(builder.status());
}
absl::Status s = builder.Finish();
TF_CHECK_OK(s) << s.ToString();
CHECK_EQ(sink.contents().size(), builder.FileSize());
source_ = new StringSource(sink.contents());
Options table_options;
return Table::Open(table_options, source_, sink.contents().size(), &table_);
}
Iterator* NewIterator() const override { return table_->NewIterator(); }
uint64 ApproximateOffsetOf(const StringPiece& key) const {
return table_->ApproximateOffsetOf(key);
}
uint64 BytesRead() const { return source_->BytesRead(); }
private:
void Reset() {
delete table_;
delete source_;
table_ = nullptr;
source_ = nullptr;
}
StringSource* source_;
Table* table_;
};
enum TestType { TABLE_TEST, BLOCK_TEST };
struct TestArgs {
TestType type;
int restart_interval;
};
static const TestArgs kTestArgList[] = {
{TABLE_TEST, 16}, {TABLE_TEST, 1}, {TABLE_TEST, 1024},
{BLOCK_TEST, 16}, {BLOCK_TEST, 1}, {BLOCK_TEST, 1024},
};
static const int kNumTestArgs = sizeof(kTestArgList) / sizeof(kTestArgList[0]);
class Harness : public ::testing::Test {
public:
Harness() : constructor_(nullptr) {}
void Init(const TestArgs& args) {
delete constructor_;
constructor_ = nullptr;
options_ = Options();
options_.block_restart_interval = args.restart_interval;
options_.block_size = 256;
switch (args.type) {
case TABLE_TEST:
constructor_ = new TableConstructor();
break;
case BLOCK_TEST:
constructor_ = new BlockConstructor();
break;
}
}
~Harness() override { delete constructor_; }
void Add(const string& key, const string& value) {
constructor_->Add(key, value);
}
void Test(random::SimplePhilox* rnd, int num_random_access_iters = 200) {
std::vector<string> keys;
KVMap data;
constructor_->Finish(options_, &keys, &data);
TestForwardScan(keys, data);
TestRandomAccess(rnd, keys, data, num_random_access_iters);
}
void TestForwardScan(const std::vector<string>& keys, const KVMap& data) {
Iterator* iter = constructor_->NewIterator();
ASSERT_TRUE(!iter->Valid());
iter->SeekToFirst();
for (KVMap::const_iterator model_iter = data.begin();
model_iter != data.end(); ++model_iter) {
ASSERT_EQ(ToStringPiecePair(data, model_iter), ToStringPiecePair(iter));
iter->Next();
}
ASSERT_TRUE(!iter->Valid());
delete iter;
}
void TestRandomAccess(random::SimplePhilox* rnd,
const std::vector<string>& keys, const KVMap& data,
int num_random_access_iters) {
static const bool kVerbose = false;
Iterator* iter = constructor_->NewIterator();
ASSERT_TRUE(!iter->Valid());
KVMap::const_iterator model_iter = data.begin();
if (kVerbose) fprintf(stderr, "---\n");
for (int i = 0; i < num_random_access_iters; i++) {
const int toss = rnd->Uniform(3);
switch (toss) {
case 0: {
if (iter->Valid()) {
if (kVerbose) fprintf(stderr, "Next\n");
iter->Next();
++model_iter;
ASSERT_EQ(ToStringPiecePair(data, model_iter),
ToStringPiecePair(iter));
}
break;
}
case 1: {
if (kVerbose) fprintf(stderr, "SeekToFirst\n");
iter->SeekToFirst();
model_iter = data.begin();
ASSERT_EQ(ToStringPiecePair(data, model_iter),
ToStringPiecePair(iter));
break;
}
case 2: {
string key = PickRandomKey(rnd, keys);
model_iter = data.lower_bound(key);
if (kVerbose)
fprintf(stderr, "Seek '%s'\n", absl::CEscape(key).c_str());
iter->Seek(StringPiece(key));
ASSERT_EQ(ToStringPiecePair(data, model_iter),
ToStringPiecePair(iter));
break;
}
}
}
delete iter;
}
StringPiecePair ToStringPiecePair(const KVMap& data,
const KVMap::const_iterator& it) {
if (it == data.end()) {
return StringPiecePair("END", "");
} else {
return StringPiecePair(it->first, it->second);
}
}
StringPiecePair ToStringPiecePair(const KVMap& data,
const KVMap::const_reverse_iterator& it) {
if (it == data.rend()) {
return StringPiecePair("END", "");
} else {
return StringPiecePair(it->first, it->second);
}
}
StringPiecePair ToStringPiecePair(const Iterator* it) {
if (!it->Valid()) {
return StringPiecePair("END", "");
} else {
return StringPiecePair(it->key(), it->value());
}
}
string PickRandomKey(random::SimplePhilox* rnd,
const std::vector<string>& keys) {
if (keys.empty()) {
return "foo";
} else {
const int index = rnd->Uniform(keys.size());
string result = keys[index];
switch (rnd->Uniform(3)) {
case 0:
break;
case 1: {
if (!result.empty() && result[result.size() - 1] > '\0') {
result[result.size() - 1]--;
}
break;
}
case 2: {
Increment(&result);
break;
}
}
return result;
}
}
private:
Options options_;
Constructor* constructor_;
};
TEST_F(Harness, Empty) {
for (int i = 0; i < kNumTestArgs; i++) {
Init(kTestArgList[i]);
random::PhiloxRandom philox(testing::RandomSeed() + 1, 17);
random::SimplePhilox rnd(&philox);
Test(&rnd);
}
}
TEST_F(Harness, ZeroRestartPointsInBlock) {
char data[sizeof(uint32)];
memset(data, 0, sizeof(data));
BlockContents contents;
contents.data = StringPiece(data, sizeof(data));
contents.cacheable = false;
contents.heap_allocated = false;
Block block(contents);
Iterator* iter = block.NewIterator();
iter->SeekToFirst();
ASSERT_TRUE(!iter->Valid());
iter->Seek("foo");
ASSERT_TRUE(!iter->Valid());
delete iter;
}
TEST_F(Harness, SimpleEmptyKey) {
for (int i = 0; i < kNumTestArgs; i++) {
Init(kTestArgList[i]);
random::PhiloxRandom philox(testing::RandomSeed() + 1, 17);
random::SimplePhilox rnd(&philox);
Add("", "v");
Test(&rnd);
}
}
TEST_F(Harness, SimpleSingle) {
for (int i = 0; i < kNumTestArgs; i++) {
Init(kTestArgList[i]);
random::PhiloxRandom philox(testing::RandomSeed() + 2, 17);
random::SimplePhilox rnd(&philox);
Add("abc", "v");
Test(&rnd);
}
}
TEST_F(Harness, SimpleMulti) {
for (int i = 0; i < kNumTestArgs; i++) {
Init(kTestArgList[i]);
random::PhiloxRandom philox(testing::RandomSeed() + 3, 17);
random::SimplePhilox rnd(&philox);
Add("abc", "v");
Add("abcd", "v");
Add("ac", "v2");
Test(&rnd);
}
}
TEST_F(Harness, SimpleMultiBigValues) {
for (int i = 0; i < kNumTestArgs; i++) {
Init(kTestArgList[i]);
random::PhiloxRandom philox(testing::RandomSeed() + 3, 17);
random::SimplePhilox rnd(&philox);
Add("ainitial", "tiny");
Add("anext", string(10000000, 'a'));
Add("anext2", string(10000000, 'b'));
Add("azz", "tiny");
Test(&rnd, 100 );
}
}
TEST_F(Harness, SimpleSpecialKey) {
for (int i = 0; i < kNumTestArgs; i++) {
Init(kTestArgList[i]);
random::PhiloxRandom philox(testing::RandomSeed() + 4, 17);
random::SimplePhilox rnd(&philox);
Add("\xff\xff", "v3");
Test(&rnd);
}
}
TEST_F(Harness, Randomized) {
for (int i = 0; i < kNumTestArgs; i++) {
Init(kTestArgList[i]);
random::PhiloxRandom philox(testing::RandomSeed() + 5, 17);
random::SimplePhilox rnd(&philox);
for (int num_entries = 0; num_entries < 2000;
num_entries += (num_entries < 50 ? 1 : 200)) {
if ((num_entries % 10) == 0) {
fprintf(stderr, "case %d of %d: num_entries = %d\n", (i + 1),
int(kNumTestArgs), num_entries);
}
for (int e = 0; e < num_entries; e++) {
string v;
Add(test::RandomKey(&rnd, rnd.Skewed(4)),
string(test::RandomString(&rnd, rnd.Skewed(5), &v)));
}
Test(&rnd);
}
}
}
static bool Between(uint64 val, uint64 low, uint64 high) {
bool result = (val >= low) && (val <= high);
if (!result) {
fprintf(stderr, "Value %llu is not in range [%llu, %llu]\n",
static_cast<unsigned long long>(val),
static_cast<unsigned long long>(low),
static_cast<unsigned long long>(high));
}
return result;
}
class TableTest {};
TEST(TableTest, ApproximateOffsetOfPlain) {
TableConstructor c;
c.Add("k01", "hello");
c.Add("k02", "hello2");
c.Add("k03", string(10000, 'x'));
c.Add("k04", string(200000, 'x'));
c.Add("k05", string(300000, 'x'));
c.Add("k06", "hello3");
c.Add("k07", string(100000, 'x'));
std::vector<string> keys;
KVMap kvmap;
Options options;
options.block_size = 1024;
options.compression = kNoCompression;
c.Finish(options, &keys, &kvmap);
ASSERT_TRUE(Between(c.ApproximateOffsetOf("abc"), 0, 0));
ASSERT_TRUE(Between(c.ApproximateOffsetOf("k01"), 0, 0));
ASSERT_TRUE(Between(c.ApproximateOffsetOf("k01a"), 0, 0));
ASSERT_TRUE(Between(c.ApproximateOffsetOf("k02"), 0, 0));
ASSERT_TRUE(Between(c.ApproximateOffsetOf("k03"), 10, 500));
ASSERT_TRUE(Between(c.ApproximateOffsetOf("k04"), 10000, 11000));
ASSERT_TRUE(Between(c.ApproximateOffsetOf("k04a"), 210000, 211000));
ASSERT_TRUE(Between(c.ApproximateOffsetOf("k05"), 210000, 211000));
ASSERT_TRUE(Between(c.ApproximateOffsetOf("k06"), 510000, 511000));
ASSERT_TRUE(Between(c.ApproximateOffsetOf("k07"), 510000, 511000));
ASSERT_TRUE(Between(c.ApproximateOffsetOf("xyz"), 610000, 612000));
}
static bool SnappyCompressionSupported() {
string out;
StringPiece in = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
return port::Snappy_Compress(in.data(), in.size(), &out);
}
TEST(TableTest, ApproximateOffsetOfCompressed) {
if (!SnappyCompressionSupported()) {
fprintf(stderr, "skipping compression tests\n");
return;
}
random::PhiloxRandom philox(301, 17);
random::SimplePhilox rnd(&philox);
TableConstructor c;
string tmp;
c.Add("k01", "hello");
c.Add("k02", test::CompressibleString(&rnd, 0.25, 10000, &tmp));
c.Add("k03", "hello3");
c.Add("k04", test::CompressibleString(&rnd, 0.25, 10000, &tmp));
std::vector<string> keys;
KVMap kvmap;
Options options;
options.block_size = 1024;
options.compression = kSnappyCompression;
c.Finish(options, &keys, &kvmap);
ASSERT_TRUE(Between(c.ApproximateOffsetOf("abc"), 0, 0));
ASSERT_TRUE(Between(c.ApproximateOffsetOf("k01"), 0, 0));
ASSERT_TRUE(Between(c.ApproximateOffsetOf("k02"), 10, 100));
ASSERT_TRUE(Between(c.ApproximateOffsetOf("k03"), 2000, 4000));
ASSERT_TRUE(Between(c.ApproximateOffsetOf("k04"), 2000, 4000));
ASSERT_TRUE(Between(c.ApproximateOffsetOf("xyz"), 4000, 7000));
}
TEST(TableTest, SeekToFirstKeyDoesNotReadTooMuch) {
random::PhiloxRandom philox(301, 17);
random::SimplePhilox rnd(&philox);
string tmp;
TableConstructor c;
c.Add("k01", "firstvalue");
c.Add("k03", test::CompressibleString(&rnd, 0.25, 1000000, &tmp));
c.Add("k04", "abc");
std::vector<string> keys;
KVMap kvmap;
Options options;
options.block_size = 1024;
options.compression = kNoCompression;
c.Finish(options, &keys, &kvmap);
Iterator* iter = c.NewIterator();
iter->Seek("k01");
delete iter;
EXPECT_LT(c.BytesRead(), 200);
}
}
} |
2,648 | cpp | google/tsl | random_inputstream | tsl/lib/io/random_inputstream.cc | tsl/lib/io/random_inputstream_test.cc | #ifndef TENSORFLOW_TSL_LIB_IO_RANDOM_INPUTSTREAM_H_
#define TENSORFLOW_TSL_LIB_IO_RANDOM_INPUTSTREAM_H_
#include "tsl/lib/io/inputstream_interface.h"
#include "tsl/platform/cord.h"
#include "tsl/platform/file_system.h"
namespace tsl {
namespace io {
class RandomAccessInputStream : public InputStreamInterface {
public:
RandomAccessInputStream(RandomAccessFile* file, bool owns_file = false);
~RandomAccessInputStream() override;
absl::Status ReadNBytes(int64_t bytes_to_read, tstring* result) override;
#if defined(TF_CORD_SUPPORT)
absl::Status ReadNBytes(int64_t bytes_to_read, absl::Cord* result) override;
#endif
absl::Status SkipNBytes(int64_t bytes_to_skip) override;
int64_t Tell() const override;
absl::Status Seek(int64_t position) {
pos_ = position;
return absl::OkStatus();
}
absl::Status Reset() override { return Seek(0); }
private:
RandomAccessFile* file_;
int64_t pos_ = 0;
bool owns_file_ = false;
};
}
}
#endif
#include "tsl/lib/io/random_inputstream.h"
#include <memory>
namespace tsl {
namespace io {
RandomAccessInputStream::RandomAccessInputStream(RandomAccessFile* file,
bool owns_file)
: file_(file), owns_file_(owns_file) {}
RandomAccessInputStream::~RandomAccessInputStream() {
if (owns_file_) {
delete file_;
}
}
absl::Status RandomAccessInputStream::ReadNBytes(int64_t bytes_to_read,
tstring* result) {
if (bytes_to_read < 0) {
return errors::InvalidArgument("Cannot read negative number of bytes");
}
result->clear();
result->resize_uninitialized(bytes_to_read);
char* result_buffer = &(*result)[0];
StringPiece data;
absl::Status s = file_->Read(pos_, bytes_to_read, &data, result_buffer);
if (data.data() != result_buffer) {
memmove(result_buffer, data.data(), data.size());
}
result->resize(data.size());
if (s.ok() || errors::IsOutOfRange(s)) {
pos_ += data.size();
}
return s;
}
#if defined(TF_CORD_SUPPORT)
absl::Status RandomAccessInputStream::ReadNBytes(int64_t bytes_to_read,
absl::Cord* result) {
if (bytes_to_read < 0) {
return errors::InvalidArgument("Cannot read negative number of bytes");
}
int64_t current_size = result->size();
absl::Status s = file_->Read(pos_, bytes_to_read, result);
if (s.ok() || errors::IsOutOfRange(s)) {
pos_ += result->size() - current_size;
}
return s;
}
#endif
static constexpr int64_t kMaxSkipSize = 8 * 1024 * 1024;
absl::Status RandomAccessInputStream::SkipNBytes(int64_t bytes_to_skip) {
if (bytes_to_skip < 0) {
return errors::InvalidArgument("Can't skip a negative number of bytes");
}
std::unique_ptr<char[]> scratch(new char[kMaxSkipSize]);
if (bytes_to_skip > 0) {
StringPiece data;
absl::Status s =
file_->Read(pos_ + bytes_to_skip - 1, 1, &data, scratch.get());
if ((s.ok() || errors::IsOutOfRange(s)) && data.size() == 1) {
pos_ += bytes_to_skip;
return absl::OkStatus();
}
}
while (bytes_to_skip > 0) {
int64_t bytes_to_read = std::min<int64_t>(kMaxSkipSize, bytes_to_skip);
StringPiece data;
absl::Status s = file_->Read(pos_, bytes_to_read, &data, scratch.get());
if (s.ok() || errors::IsOutOfRange(s)) {
pos_ += data.size();
} else {
return s;
}
if (data.size() < static_cast<size_t>(bytes_to_read)) {
return errors::OutOfRange("reached end of file");
}
bytes_to_skip -= bytes_to_read;
}
return absl::OkStatus();
}
int64_t RandomAccessInputStream::Tell() const { return pos_; }
}
} | #include "tsl/lib/io/random_inputstream.h"
#include "tsl/lib/core/status_test_util.h"
#include "tsl/platform/env.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace io {
namespace {
TEST(RandomInputStream, ReadNBytes) {
Env* env = Env::Default();
string fname = testing::TmpDir() + "/random_inputbuffer_test";
TF_ASSERT_OK(WriteStringToFile(env, fname, "0123456789"));
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
tstring read;
RandomAccessInputStream in(file.get());
TF_ASSERT_OK(in.ReadNBytes(3, &read));
EXPECT_EQ(read, "012");
EXPECT_EQ(3, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(0, &read));
EXPECT_EQ(read, "");
EXPECT_EQ(3, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(5, &read));
EXPECT_EQ(read, "34567");
EXPECT_EQ(8, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(0, &read));
EXPECT_EQ(read, "");
EXPECT_EQ(8, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.ReadNBytes(20, &read)));
EXPECT_EQ(read, "89");
EXPECT_EQ(10, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(0, &read));
EXPECT_EQ(read, "");
EXPECT_EQ(10, in.Tell());
}
#if defined(TF_CORD_SUPPORT)
TEST(RandomInputStream, ReadNBytesWithCords) {
Env* env = Env::Default();
string fname = testing::TmpDir() + "/random_inputbuffer_test";
TF_ASSERT_OK(WriteStringToFile(env, fname, "0123456789"));
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
absl::Cord read;
RandomAccessInputStream in(file.get());
TF_ASSERT_OK(in.ReadNBytes(3, &read));
EXPECT_EQ(read, "012");
EXPECT_EQ(3, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(0, &read));
EXPECT_EQ(read, "012");
EXPECT_EQ(3, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(5, &read));
EXPECT_EQ(read, "01234567");
EXPECT_EQ(8, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(0, &read));
EXPECT_EQ(read, "01234567");
EXPECT_EQ(8, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.ReadNBytes(20, &read)));
EXPECT_EQ(read, "0123456789");
EXPECT_EQ(10, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(0, &read));
EXPECT_EQ(read, "0123456789");
EXPECT_EQ(10, in.Tell());
}
#endif
TEST(RandomInputStream, SkipNBytes) {
Env* env = Env::Default();
string fname = testing::TmpDir() + "/random_inputbuffer_test";
TF_ASSERT_OK(WriteStringToFile(env, fname, "0123456789"));
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
tstring read;
RandomAccessInputStream in(file.get());
TF_ASSERT_OK(in.SkipNBytes(3));
EXPECT_EQ(3, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(0, &read));
EXPECT_EQ(read, "");
EXPECT_EQ(3, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(4, &read));
EXPECT_EQ(read, "3456");
EXPECT_EQ(7, in.Tell());
TF_ASSERT_OK(in.SkipNBytes(0));
EXPECT_EQ(7, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(2, &read));
EXPECT_EQ(read, "78");
EXPECT_EQ(9, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.SkipNBytes(20)));
EXPECT_EQ(10, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.ReadNBytes(5, &read)));
EXPECT_EQ(read, "");
EXPECT_EQ(10, in.Tell());
}
TEST(RandomInputStream, Seek) {
Env* env = Env::Default();
string fname = testing::TmpDir() + "/random_inputbuffer_seek_test";
TF_ASSERT_OK(WriteStringToFile(env, fname, "0123456789"));
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
tstring read;
RandomAccessInputStream in(file.get());
TF_ASSERT_OK(in.Seek(3));
EXPECT_EQ(3, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(4, &read));
EXPECT_EQ(read, "3456");
EXPECT_EQ(7, in.Tell());
TF_ASSERT_OK(in.Seek(1));
TF_ASSERT_OK(in.ReadNBytes(4, &read));
EXPECT_EQ(read, "1234");
EXPECT_EQ(5, in.Tell());
}
}
}
} |
2,649 | cpp | google/tsl | buffered_inputstream | tsl/lib/io/buffered_inputstream.cc | tsl/lib/io/buffered_inputstream_test.cc | #ifndef TENSORFLOW_TSL_LIB_IO_BUFFERED_INPUTSTREAM_H_
#define TENSORFLOW_TSL_LIB_IO_BUFFERED_INPUTSTREAM_H_
#include <string>
#include "tsl/lib/io/inputstream_interface.h"
#include "tsl/platform/file_system.h"
namespace tsl {
namespace io {
class BufferedInputStream : public InputStreamInterface {
public:
BufferedInputStream(InputStreamInterface* input_stream, size_t buffer_bytes,
bool owns_input_stream = false);
BufferedInputStream(RandomAccessFile* file, size_t buffer_bytes);
~BufferedInputStream() override;
absl::Status ReadNBytes(int64_t bytes_to_read, tstring* result) override;
absl::Status SkipNBytes(int64_t bytes_to_skip) override;
int64_t Tell() const override;
absl::Status Seek(int64_t position);
absl::Status ReadLine(std::string* result);
absl::Status ReadLine(tstring* result);
std::string ReadLineAsString();
absl::Status SkipLine();
template <typename T>
absl::Status ReadAll(T* result);
absl::Status Reset() override;
private:
absl::Status FillBuffer();
template <typename StringType>
absl::Status ReadLineHelper(StringType* result, bool include_eol);
InputStreamInterface* input_stream_;
size_t size_;
tstring buf_;
size_t pos_ = 0;
size_t limit_ = 0;
bool owns_input_stream_ = false;
absl::Status file_status_ = absl::OkStatus();
BufferedInputStream(const BufferedInputStream&) = delete;
void operator=(const BufferedInputStream&) = delete;
};
#ifndef SWIG
extern template Status BufferedInputStream::ReadAll<std::string>(
std::string* result);
extern template Status BufferedInputStream::ReadAll<tstring>(tstring* result);
#endif
}
}
#endif
#include "tsl/lib/io/buffered_inputstream.h"
#include "absl/status/status.h"
#include "tsl/lib/io/random_inputstream.h"
namespace tsl {
namespace io {
BufferedInputStream::BufferedInputStream(InputStreamInterface* input_stream,
size_t buffer_bytes,
bool owns_input_stream)
: input_stream_(input_stream),
size_(buffer_bytes),
owns_input_stream_(owns_input_stream) {
buf_.reserve(size_);
}
BufferedInputStream::BufferedInputStream(RandomAccessFile* file,
size_t buffer_bytes)
: BufferedInputStream(new RandomAccessInputStream(file), buffer_bytes,
true) {}
BufferedInputStream::~BufferedInputStream() {
if (owns_input_stream_) {
delete input_stream_;
}
}
absl::Status BufferedInputStream::FillBuffer() {
if (!file_status_.ok()) {
pos_ = 0;
limit_ = 0;
return file_status_;
}
absl::Status s = input_stream_->ReadNBytes(size_, &buf_);
pos_ = 0;
limit_ = buf_.size();
if (!s.ok()) {
file_status_ = s;
}
return s;
}
template <typename StringType>
absl::Status BufferedInputStream::ReadLineHelper(StringType* result,
bool include_eol) {
result->clear();
absl::Status s;
size_t start_pos = pos_;
while (true) {
if (pos_ == limit_) {
result->append(buf_.data() + start_pos, pos_ - start_pos);
s = FillBuffer();
if (limit_ == 0) {
break;
}
start_pos = pos_;
}
char c = buf_[pos_];
if (c == '\n') {
result->append(buf_.data() + start_pos, pos_ - start_pos);
if (include_eol) {
result->append(1, c);
}
pos_++;
return absl::OkStatus();
}
if (c == '\r') {
result->append(buf_.data() + start_pos, pos_ - start_pos);
start_pos = pos_ + 1;
}
pos_++;
}
if (absl::IsOutOfRange(s) && !result->empty()) {
return absl::OkStatus();
}
return s;
}
absl::Status BufferedInputStream::ReadNBytes(int64_t bytes_to_read,
tstring* result) {
if (bytes_to_read < 0) {
return errors::InvalidArgument("Can't read a negative number of bytes: ",
bytes_to_read);
}
result->clear();
if (pos_ == limit_ && !file_status_.ok() && bytes_to_read > 0) {
return file_status_;
}
result->reserve(bytes_to_read);
absl::Status s;
while (result->size() < static_cast<size_t>(bytes_to_read)) {
if (pos_ == limit_) {
s = FillBuffer();
if (limit_ == 0) {
DCHECK(!s.ok());
file_status_ = s;
break;
}
}
const int64_t bytes_to_copy =
std::min<int64_t>(limit_ - pos_, bytes_to_read - result->size());
result->insert(result->size(), buf_, pos_, bytes_to_copy);
pos_ += bytes_to_copy;
}
if (absl::IsOutOfRange(s) &&
(result->size() == static_cast<size_t>(bytes_to_read))) {
return absl::OkStatus();
}
return s;
}
absl::Status BufferedInputStream::SkipNBytes(int64_t bytes_to_skip) {
if (bytes_to_skip < 0) {
return errors::InvalidArgument("Can only skip forward, not ",
bytes_to_skip);
}
if (pos_ + bytes_to_skip < limit_) {
pos_ += bytes_to_skip;
} else {
absl::Status s = input_stream_->SkipNBytes(bytes_to_skip - (limit_ - pos_));
pos_ = 0;
limit_ = 0;
if (absl::IsOutOfRange(s)) {
file_status_ = s;
}
return s;
}
return absl::OkStatus();
}
int64_t BufferedInputStream::Tell() const {
return input_stream_->Tell() - (limit_ - pos_);
}
absl::Status BufferedInputStream::Seek(int64_t position) {
if (position < 0) {
return errors::InvalidArgument("Seeking to a negative position: ",
position);
}
const int64_t buf_lower_limit = input_stream_->Tell() - limit_;
if (position < buf_lower_limit) {
TF_RETURN_IF_ERROR(Reset());
return SkipNBytes(position);
}
if (position < Tell()) {
pos_ -= Tell() - position;
return absl::OkStatus();
}
return SkipNBytes(position - Tell());
}
template <typename T>
absl::Status BufferedInputStream::ReadAll(T* result) {
result->clear();
absl::Status status;
while (status.ok()) {
status = FillBuffer();
if (limit_ == 0) {
break;
}
result->append(buf_);
pos_ = limit_;
}
if (absl::IsOutOfRange(status)) {
file_status_ = status;
return absl::OkStatus();
}
return status;
}
template Status BufferedInputStream::ReadAll<std::string>(std::string* result);
template Status BufferedInputStream::ReadAll<tstring>(tstring* result);
absl::Status BufferedInputStream::Reset() {
TF_RETURN_IF_ERROR(input_stream_->Reset());
pos_ = 0;
limit_ = 0;
file_status_ = absl::OkStatus();
return absl::OkStatus();
}
absl::Status BufferedInputStream::ReadLine(std::string* result) {
return ReadLineHelper(result, false);
}
absl::Status BufferedInputStream::ReadLine(tstring* result) {
return ReadLineHelper(result, false);
}
std::string BufferedInputStream::ReadLineAsString() {
std::string result;
ReadLineHelper(&result, true).IgnoreError();
return result;
}
absl::Status BufferedInputStream::SkipLine() {
absl::Status s;
bool skipped = false;
while (true) {
if (pos_ == limit_) {
s = FillBuffer();
if (limit_ == 0) {
break;
}
}
char c = buf_[pos_++];
skipped = true;
if (c == '\n') {
return absl::OkStatus();
}
}
if (absl::IsOutOfRange(s) && skipped) {
return absl::OkStatus();
}
return s;
}
}
} | #include "tsl/lib/io/buffered_inputstream.h"
#include "tsl/lib/core/status_test_util.h"
#include "tsl/lib/io/random_inputstream.h"
#include "tsl/platform/env.h"
#include "tsl/platform/test.h"
#include "tsl/platform/test_benchmark.h"
namespace tsl {
namespace io {
namespace {
static std::vector<int> BufferSizes() {
return {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20, 65536};
}
class ReadOnceInputStream : public InputStreamInterface {
public:
ReadOnceInputStream() : start_(true) {}
virtual absl::Status ReadNBytes(int64_t bytes_to_read, tstring* result) {
if (bytes_to_read < 11) {
return errors::InvalidArgument("Not reading all bytes: ", bytes_to_read);
}
if (start_) {
*result = "0123456789";
start_ = false;
return errors::OutOfRange("Out of range.");
}
return errors::InvalidArgument(
"Redudant call to ReadNBytes after an OutOfRange error.");
}
int64_t Tell() const override { return start_ ? 0 : 10; }
absl::Status Reset() override {
start_ = true;
return absl::OkStatus();
}
private:
bool start_;
};
TEST(BufferedInputStream, ReadLine_Empty) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(WriteStringToFile(env, fname, ""));
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessInputStream> input_stream(
new RandomAccessInputStream(file.get()));
BufferedInputStream in(input_stream.get(), buf_size);
string line;
EXPECT_TRUE(errors::IsOutOfRange(in.ReadLine(&line)));
}
}
TEST(BufferedInputStream, ReadLine1) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(
WriteStringToFile(env, fname, "line one\nline two\nline three\n"));
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessInputStream> input_stream(
new RandomAccessInputStream(file.get()));
BufferedInputStream in(input_stream.get(), buf_size);
string line;
TF_ASSERT_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line one");
TF_ASSERT_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line two");
TF_ASSERT_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line three");
EXPECT_TRUE(errors::IsOutOfRange(in.ReadLine(&line)));
EXPECT_TRUE(errors::IsOutOfRange(in.ReadLine(&line)));
}
}
TEST(BufferedInputStream, ReadLine_NoTrailingNewLine) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(WriteStringToFile(env, fname, "line one\nline two\nline three"));
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessInputStream> input_stream(
new RandomAccessInputStream(file.get()));
BufferedInputStream in(input_stream.get(), buf_size);
string line;
TF_ASSERT_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line one");
TF_ASSERT_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line two");
TF_ASSERT_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line three");
EXPECT_TRUE(errors::IsOutOfRange(in.ReadLine(&line)));
EXPECT_TRUE(errors::IsOutOfRange(in.ReadLine(&line)));
}
}
TEST(BufferedInputStream, ReadLine_EmptyLines) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(
WriteStringToFile(env, fname, "line one\n\n\nline two\nline three"));
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessInputStream> input_stream(
new RandomAccessInputStream(file.get()));
BufferedInputStream in(input_stream.get(), buf_size);
string line;
TF_ASSERT_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line one");
TF_ASSERT_OK(in.ReadLine(&line));
EXPECT_EQ(line, "");
TF_ASSERT_OK(in.ReadLine(&line));
EXPECT_EQ(line, "");
TF_ASSERT_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line two");
TF_ASSERT_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line three");
EXPECT_TRUE(errors::IsOutOfRange(in.ReadLine(&line)));
EXPECT_TRUE(errors::IsOutOfRange(in.ReadLine(&line)));
}
}
TEST(BufferedInputStream, ReadLine_CRLF) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(WriteStringToFile(env, fname,
"line one\r\n\r\n\r\nline two\r\nline three"));
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessInputStream> input_stream(
new RandomAccessInputStream(file.get()));
BufferedInputStream in(input_stream.get(), buf_size);
string line;
TF_ASSERT_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line one");
TF_ASSERT_OK(in.ReadLine(&line));
EXPECT_EQ(line, "");
TF_ASSERT_OK(in.ReadLine(&line));
EXPECT_EQ(line, "");
TF_ASSERT_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line two");
TF_ASSERT_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line three");
EXPECT_TRUE(errors::IsOutOfRange(in.ReadLine(&line)));
EXPECT_TRUE(errors::IsOutOfRange(in.ReadLine(&line)));
}
}
TEST(BufferedInputStream, SkipLine1) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(
WriteStringToFile(env, fname, "line one\nline two\nline three\n"));
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessInputStream> input_stream(
new RandomAccessInputStream(file.get()));
BufferedInputStream in(input_stream.get(), buf_size);
string line;
TF_ASSERT_OK(in.SkipLine());
TF_ASSERT_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line two");
TF_ASSERT_OK(in.SkipLine());
EXPECT_TRUE(errors::IsOutOfRange(in.SkipLine()));
EXPECT_TRUE(errors::IsOutOfRange(in.SkipLine()));
}
}
TEST(BufferedInputStream, SkipLine_NoTrailingNewLine) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(WriteStringToFile(env, fname, "line one\nline two\nline three"));
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessInputStream> input_stream(
new RandomAccessInputStream(file.get()));
BufferedInputStream in(input_stream.get(), buf_size);
string line;
TF_ASSERT_OK(in.SkipLine());
TF_ASSERT_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line two");
TF_ASSERT_OK(in.SkipLine());
EXPECT_TRUE(errors::IsOutOfRange(in.SkipLine()));
EXPECT_TRUE(errors::IsOutOfRange(in.SkipLine()));
}
}
TEST(BufferedInputStream, SkipLine_EmptyLines) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(WriteStringToFile(env, fname, "line one\n\n\nline two"));
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessInputStream> input_stream(
new RandomAccessInputStream(file.get()));
BufferedInputStream in(input_stream.get(), buf_size);
string line;
TF_ASSERT_OK(in.SkipLine());
TF_ASSERT_OK(in.ReadLine(&line));
EXPECT_EQ(line, "");
TF_ASSERT_OK(in.SkipLine());
TF_ASSERT_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line two");
}
}
TEST(BufferedInputStream, ReadNBytes) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(WriteStringToFile(env, fname, "0123456789"));
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessInputStream> input_stream(
new RandomAccessInputStream(file.get()));
tstring read;
BufferedInputStream in(input_stream.get(), buf_size);
EXPECT_EQ(0, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(3, &read));
EXPECT_EQ(read, "012");
EXPECT_EQ(3, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(0, &read));
EXPECT_EQ(read, "");
EXPECT_EQ(3, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(4, &read));
EXPECT_EQ(read, "3456");
EXPECT_EQ(7, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(0, &read));
EXPECT_EQ(read, "");
EXPECT_EQ(7, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.ReadNBytes(5, &read)));
EXPECT_EQ(read, "789");
EXPECT_EQ(10, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.ReadNBytes(5, &read)));
EXPECT_EQ(read, "");
EXPECT_EQ(10, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(0, &read));
EXPECT_EQ(read, "");
EXPECT_EQ(10, in.Tell());
}
}
TEST(BufferedInputStream, OutOfRangeCache) {
for (auto buf_size : BufferSizes()) {
if (buf_size < 11) {
continue;
}
ReadOnceInputStream input_stream;
tstring read;
BufferedInputStream in(&input_stream, buf_size);
EXPECT_EQ(0, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(3, &read));
EXPECT_EQ(read, "012");
EXPECT_EQ(3, in.Tell());
TF_ASSERT_OK((in.ReadNBytes(7, &read)));
EXPECT_EQ(read, "3456789");
EXPECT_EQ(10, in.Tell());
absl::Status s = in.ReadNBytes(5, &read);
EXPECT_EQ(error::OUT_OF_RANGE, s.code()) << s;
EXPECT_EQ(read, "");
TF_ASSERT_OK(in.ReadNBytes(0, &read));
EXPECT_EQ(read, "");
}
}
TEST(BufferedInputStream, SkipNBytes) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(WriteStringToFile(env, fname, "0123456789"));
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessInputStream> input_stream(
new RandomAccessInputStream(file.get()));
tstring read;
BufferedInputStream in(input_stream.get(), buf_size);
EXPECT_EQ(0, in.Tell());
TF_ASSERT_OK(in.SkipNBytes(3));
EXPECT_EQ(3, in.Tell());
TF_ASSERT_OK(in.SkipNBytes(0));
EXPECT_EQ(3, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(2, &read));
EXPECT_EQ(read, "34");
EXPECT_EQ(5, in.Tell());
TF_ASSERT_OK(in.SkipNBytes(0));
EXPECT_EQ(5, in.Tell());
TF_ASSERT_OK(in.SkipNBytes(2));
EXPECT_EQ(7, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(1, &read));
EXPECT_EQ(read, "7");
EXPECT_EQ(8, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.SkipNBytes(5)));
EXPECT_EQ(10, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.SkipNBytes(5)));
EXPECT_EQ(10, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.ReadNBytes(5, &read)));
EXPECT_EQ(read, "");
EXPECT_EQ(10, in.Tell());
}
}
TEST(BufferedInputStream, ReadNBytesRandomAccessFile) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(WriteStringToFile(env, fname, "0123456789"));
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
for (auto buf_size : BufferSizes()) {
tstring read;
BufferedInputStream in(file.get(), buf_size);
EXPECT_EQ(0, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(3, &read));
EXPECT_EQ(read, "012");
EXPECT_EQ(3, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(0, &read));
EXPECT_EQ(read, "");
EXPECT_EQ(3, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(4, &read));
EXPECT_EQ(read, "3456");
EXPECT_EQ(7, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(0, &read));
EXPECT_EQ(read, "");
EXPECT_EQ(7, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.ReadNBytes(5, &read)));
EXPECT_EQ(read, "789");
EXPECT_EQ(10, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.ReadNBytes(5, &read)));
EXPECT_EQ(read, "");
EXPECT_EQ(10, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(0, &read));
EXPECT_EQ(read, "");
EXPECT_EQ(10, in.Tell());
}
}
TEST(BufferedInputStream, SkipNBytesRandomAccessFile) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(WriteStringToFile(env, fname, "0123456789"));
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
for (auto buf_size : BufferSizes()) {
tstring read;
BufferedInputStream in(file.get(), buf_size);
EXPECT_EQ(0, in.Tell());
TF_ASSERT_OK(in.SkipNBytes(3));
EXPECT_EQ(3, in.Tell());
TF_ASSERT_OK(in.SkipNBytes(0));
EXPECT_EQ(3, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(2, &read));
EXPECT_EQ(read, "34");
EXPECT_EQ(5, in.Tell());
TF_ASSERT_OK(in.SkipNBytes(0));
EXPECT_EQ(5, in.Tell());
TF_ASSERT_OK(in.SkipNBytes(2));
EXPECT_EQ(7, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(1, &read));
EXPECT_EQ(read, "7");
EXPECT_EQ(8, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.SkipNBytes(5)));
EXPECT_EQ(10, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.SkipNBytes(5)));
EXPECT_EQ(10, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.ReadNBytes(5, &read)));
EXPECT_EQ(read, "");
EXPECT_EQ(10, in.Tell());
}
}
TEST(BufferedInputStream, Seek) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(WriteStringToFile(env, fname, "0123456789"));
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessInputStream> input_stream(
new RandomAccessInputStream(file.get()));
tstring read;
BufferedInputStream in(input_stream.get(), buf_size);
TF_ASSERT_OK(in.Seek(3));
EXPECT_EQ(3, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(4, &read));
EXPECT_EQ(read, "3456");
EXPECT_EQ(7, in.Tell());
TF_ASSERT_OK(in.Seek(1));
TF_ASSERT_OK(in.ReadNBytes(4, &read));
EXPECT_EQ(read, "1234");
EXPECT_EQ(5, in.Tell());
}
}
TEST(BufferedInputStream, Seek_NotReset) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(WriteStringToFile(env, fname, "0123456789"));
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
std::unique_ptr<RandomAccessInputStream> input_stream(
new RandomAccessInputStream(file.get()));
tstring read;
BufferedInputStream in(input_stream.get(), 3);
TF_ASSERT_OK(in.ReadNBytes(4, &read));
int before_tell = input_stream.get()->Tell();
EXPECT_EQ(before_tell, 6);
TF_ASSERT_OK(in.Seek(3));
int after_tell = input_stream.get()->Tell();
EXPECT_EQ(before_tell, after_tell);
}
TEST(BufferedInputStream, ReadAll_Empty) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
const string expected = "";
TF_ASSERT_OK(WriteStringToFile(env, fname, expected));
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
for (auto buf_size : BufferSizes()) {
RandomAccessInputStream input_stream(file.get());
BufferedInputStream in(&input_stream, buf_size);
string contents;
TF_ASSERT_OK(in.ReadAll(&contents));
EXPECT_EQ(expected, contents);
}
}
TEST(BufferedInputStream, ReadAll_Text) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
const string expected = "line one\nline two\nline three";
TF_ASSERT_OK(WriteStringToFile(env, fname, expected));
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
for (auto buf_size : BufferSizes()) {
RandomAccessInputStream input_stream(file.get());
BufferedInputStream in(&input_stream, buf_size);
string contents;
TF_ASSERT_OK(in.ReadAll(&contents));
EXPECT_EQ(expected, contents);
}
}
void BM_BufferedReaderSmallReads(::testing::benchmark::State& state) {
const int buff_size = state.range(0);
const int file_size = state.range(1);
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
const string file_elem = "0123456789";
std::unique_ptr<WritableFile> write_file;
TF_ASSERT_OK(env->NewWritableFile(fname, &write_file));
for (int i = 0; i < file_size; ++i) {
TF_ASSERT_OK(write_file->Append(file_elem));
}
TF_ASSERT_OK(write_file->Close());
std::unique_ptr<RandomAccessFile> file;
TF_ASSERT_OK(env->NewRandomAccessFile(fname, &file));
tstring result;
int itr = 0;
for (auto s : state) {
BufferedInputStream in(file.get(), buff_size);
for (int64_t i = 0; i < 10 * file_size; ++i) {
TF_ASSERT_OK(in.ReadNBytes(1, &result))
<< "i: " << i << " itr: " << itr << " buff_size: " << buff_size
<< " file size: " << file_size;
}
++itr;
}
}
BENCHMARK(BM_BufferedReaderSmallReads)
->ArgPair(1, 5)
->ArgPair(1, 1024)
->ArgPair(10, 5)
->ArgPair(10, 1024)
->ArgPair(1024, 1024)
->ArgPair(1024 * 1024, 1024)
->ArgPair(1024 * 1024, 1024 * 1024)
->ArgPair(256 * 1024 * 1024, 1024);
}
}
} |
2,650 | cpp | google/tsl | inputbuffer | tsl/lib/io/inputbuffer.cc | tsl/lib/io/inputbuffer_test.cc | #ifndef TENSORFLOW_TSL_LIB_IO_INPUTBUFFER_H_
#define TENSORFLOW_TSL_LIB_IO_INPUTBUFFER_H_
#include <string>
#include "tsl/platform/coding.h"
#include "tsl/platform/env.h"
#include "tsl/platform/macros.h"
#include "tsl/platform/status.h"
#include "tsl/platform/types.h"
namespace tsl {
namespace io {
class InputBuffer {
public:
InputBuffer(RandomAccessFile* file, size_t buffer_bytes);
~InputBuffer();
template <typename T>
absl::Status ReadLine(T* result);
absl::Status ReadNBytes(int64_t bytes_to_read, std::string* result);
absl::Status ReadNBytes(int64_t bytes_to_read, char* result,
size_t* bytes_read);
absl::Status ReadVarint32(uint32* result);
absl::Status ReadVarint64(uint64* result);
absl::Status SkipNBytes(int64_t bytes_to_skip);
absl::Status Seek(int64_t position);
absl::Status Hint(int64_t bytes_to_read);
int64_t Tell() const { return file_pos_ - (limit_ - pos_); }
RandomAccessFile* file() const { return file_; }
private:
absl::Status FillBuffer();
absl::Status ReadVarint32Fallback(uint32* result);
absl::Status ReadVarint64Fallback(uint64* result);
template <typename T>
absl::Status ReadVarintFallback(T* result, int max_bytes);
RandomAccessFile* file_;
int64_t file_pos_;
size_t size_;
char* buf_;
char* pos_;
char* limit_;
InputBuffer(const InputBuffer&) = delete;
void operator=(const InputBuffer&) = delete;
};
extern template Status InputBuffer::ReadLine<std::string>(std::string* result);
extern template Status InputBuffer::ReadLine<tstring>(tstring* result);
inline absl::Status InputBuffer::ReadVarint32(uint32* result) {
if (pos_ + core::kMaxVarint32Bytes <= limit_) {
const char* offset = core::GetVarint32Ptr(pos_, limit_, result);
if (offset == nullptr) return errors::OutOfRange("Parsed past limit.");
pos_ = const_cast<char*>(offset);
return absl::OkStatus();
} else {
return ReadVarint32Fallback(result);
}
}
inline absl::Status InputBuffer::ReadVarint64(uint64* result) {
if (pos_ + core::kMaxVarint64Bytes <= limit_) {
const char* offset = core::GetVarint64Ptr(pos_, limit_, result);
if (offset == nullptr) return errors::OutOfRange("Parsed past limit.");
pos_ = const_cast<char*>(offset);
return absl::OkStatus();
} else {
return ReadVarint64Fallback(result);
}
}
}
}
#endif
#include "tsl/lib/io/inputbuffer.h"
#include <algorithm>
#include "tsl/platform/errors.h"
#include "tsl/platform/logging.h"
namespace tsl {
namespace io {
InputBuffer::InputBuffer(RandomAccessFile* file, size_t buffer_bytes)
: file_(file),
file_pos_(0),
size_(buffer_bytes),
buf_(new char[size_]),
pos_(buf_),
limit_(buf_) {}
InputBuffer::~InputBuffer() { delete[] buf_; }
absl::Status InputBuffer::FillBuffer() {
StringPiece data;
absl::Status s = file_->Read(file_pos_, size_, &data, buf_);
if (data.data() != buf_) {
memmove(buf_, data.data(), data.size());
}
pos_ = buf_;
limit_ = pos_ + data.size();
file_pos_ += data.size();
return s;
}
template <typename T>
absl::Status InputBuffer::ReadLine(T* result) {
result->clear();
absl::Status s;
do {
size_t buf_remain = limit_ - pos_;
char* newline = static_cast<char*>(memchr(pos_, '\n', buf_remain));
if (newline != nullptr) {
size_t result_len = newline - pos_;
result->append(pos_, result_len);
pos_ = newline + 1;
if (!result->empty() && result->back() == '\r') {
result->resize(result->size() - 1);
}
return absl::OkStatus();
}
if (buf_remain > 0) result->append(pos_, buf_remain);
s = FillBuffer();
DCHECK_EQ(pos_, buf_);
} while (limit_ != buf_);
if (!result->empty() && result->back() == '\r') {
result->resize(result->size() - 1);
}
if (errors::IsOutOfRange(s) && !result->empty()) {
return absl::OkStatus();
}
return s;
}
template Status InputBuffer::ReadLine<std::string>(std::string* result);
template Status InputBuffer::ReadLine<tstring>(tstring* result);
absl::Status InputBuffer::ReadNBytes(int64_t bytes_to_read,
std::string* result) {
result->clear();
if (bytes_to_read < 0) {
return errors::InvalidArgument("Can't read a negative number of bytes: ",
bytes_to_read);
}
result->resize(bytes_to_read);
size_t bytes_read = 0;
absl::Status status = ReadNBytes(bytes_to_read, &(*result)[0], &bytes_read);
if (bytes_read < bytes_to_read) result->resize(bytes_read);
return status;
}
absl::Status InputBuffer::ReadNBytes(int64_t bytes_to_read, char* result,
size_t* bytes_read) {
if (bytes_to_read < 0) {
return errors::InvalidArgument("Can't read a negative number of bytes: ",
bytes_to_read);
}
absl::Status status;
*bytes_read = 0;
while (*bytes_read < static_cast<size_t>(bytes_to_read)) {
if (pos_ == limit_) {
status = FillBuffer();
if (limit_ == buf_) {
break;
}
}
const int64_t bytes_to_copy =
std::min<int64_t>(limit_ - pos_, bytes_to_read - *bytes_read);
memcpy(result + *bytes_read, pos_, bytes_to_copy);
pos_ += bytes_to_copy;
*bytes_read += bytes_to_copy;
}
if (errors::IsOutOfRange(status) &&
(*bytes_read == static_cast<size_t>(bytes_to_read))) {
return absl::OkStatus();
}
return status;
}
absl::Status InputBuffer::ReadVarint32Fallback(uint32* result) {
absl::Status s = ReadVarintFallback(result, core::kMaxVarint32Bytes);
if (errors::IsDataLoss(s)) {
return errors::DataLoss("Stored data is too large to be a varint32.");
}
return s;
}
absl::Status InputBuffer::ReadVarint64Fallback(uint64* result) {
absl::Status s = ReadVarintFallback(result, core::kMaxVarint64Bytes);
if (errors::IsDataLoss(s)) {
return errors::DataLoss("Stored data is too large to be a varint64.");
}
return s;
}
template <typename T>
absl::Status InputBuffer::ReadVarintFallback(T* result, int max_bytes) {
uint8 scratch = 0;
auto* p = reinterpret_cast<char*>(&scratch);
size_t unused_bytes_read = 0;
*result = 0;
for (int index = 0; index < max_bytes; index++) {
int shift = 7 * index;
TF_RETURN_IF_ERROR(ReadNBytes(1, p, &unused_bytes_read));
*result |= (static_cast<T>(scratch) & 127) << shift;
if (!(scratch & 128)) return absl::OkStatus();
}
return errors::DataLoss("Stored data longer than ", max_bytes, " bytes.");
}
absl::Status InputBuffer::SkipNBytes(int64_t bytes_to_skip) {
if (bytes_to_skip < 0) {
return errors::InvalidArgument("Can only skip forward, not ",
bytes_to_skip);
}
int64_t bytes_skipped = 0;
absl::Status s;
while (bytes_skipped < bytes_to_skip) {
if (pos_ == limit_) {
s = FillBuffer();
if (limit_ == buf_) {
break;
}
}
const int64_t bytes_to_advance =
std::min<int64_t>(limit_ - pos_, bytes_to_skip - bytes_skipped);
bytes_skipped += bytes_to_advance;
pos_ += bytes_to_advance;
}
if (errors::IsOutOfRange(s) && bytes_skipped == bytes_to_skip) {
return absl::OkStatus();
}
return s;
}
absl::Status InputBuffer::Seek(int64_t position) {
if (position < 0) {
return errors::InvalidArgument("Seeking to a negative position: ",
position);
}
const int64_t bufpos = file_pos_ - static_cast<int64_t>(limit_ - buf_);
if (position >= bufpos && position < file_pos_) {
pos_ = buf_ + (position - bufpos);
DCHECK(pos_ >= buf_ && pos_ < limit_);
} else {
pos_ = limit_ = buf_;
file_pos_ = position;
}
return absl::OkStatus();
}
absl::Status InputBuffer::Hint(int64_t bytes_to_read) {
if (bytes_to_read < 0) {
return errors::InvalidArgument("Can't read a negative number of bytes: ",
bytes_to_read);
}
if (bytes_to_read > size_) {
return absl::OkStatus();
}
const int64_t bytes_remain_in_buf = static_cast<int64_t>(limit_ - pos_);
if (bytes_to_read <= bytes_remain_in_buf) {
return absl::OkStatus();
}
memmove(buf_, pos_, bytes_remain_in_buf);
pos_ = buf_;
limit_ = buf_ + bytes_remain_in_buf;
bytes_to_read -= bytes_remain_in_buf;
StringPiece data;
absl::Status s = file_->Read(file_pos_, bytes_to_read, &data, limit_);
if (data.data() != limit_) {
memmove(limit_, data.data(), data.size());
}
limit_ += data.size();
file_pos_ += data.size();
if (errors::IsOutOfRange(s) && data.size() == bytes_to_read) {
return absl::OkStatus();
} else {
return s;
}
}
}
} | #include "tsl/lib/io/inputbuffer.h"
#include <vector>
#include "tsl/lib/core/status_test_util.h"
#include "tsl/platform/coding.h"
#include "tsl/platform/env.h"
#include "tsl/platform/errors.h"
#include "tsl/platform/logging.h"
#include "tsl/platform/status.h"
#include "tsl/platform/str_util.h"
#include "tsl/platform/strcat.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace {
static std::vector<int> BufferSizes() {
return {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20, 65536};
}
TEST(InputBuffer, ReadLine_Empty) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(WriteStringToFile(env, fname, ""));
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessFile> file;
TF_CHECK_OK(env->NewRandomAccessFile(fname, &file));
string line;
io::InputBuffer in(file.get(), buf_size);
EXPECT_TRUE(errors::IsOutOfRange(in.ReadLine(&line)));
}
}
TEST(InputBuffer, ReadLine1) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_CHECK_OK(
WriteStringToFile(env, fname, "line one\nline two\nline three\n"));
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessFile> file;
TF_CHECK_OK(env->NewRandomAccessFile(fname, &file));
string line;
io::InputBuffer in(file.get(), buf_size);
TF_CHECK_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line one");
TF_CHECK_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line two");
TF_CHECK_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line three");
EXPECT_TRUE(errors::IsOutOfRange(in.ReadLine(&line)));
EXPECT_TRUE(errors::IsOutOfRange(in.ReadLine(&line)));
}
}
TEST(InputBuffer, ReadLine_NoTrailingNewLine) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(WriteStringToFile(env, fname, "line one\nline two\nline three"));
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessFile> file;
TF_CHECK_OK(env->NewRandomAccessFile(fname, &file));
string line;
io::InputBuffer in(file.get(), buf_size);
TF_CHECK_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line one");
TF_CHECK_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line two");
TF_CHECK_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line three");
EXPECT_TRUE(errors::IsOutOfRange(in.ReadLine(&line)));
EXPECT_TRUE(errors::IsOutOfRange(in.ReadLine(&line)));
}
}
TEST(InputBuffer, ReadLine_EmptyLines) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_CHECK_OK(
WriteStringToFile(env, fname, "line one\n\n\nline two\nline three"));
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessFile> file;
TF_CHECK_OK(env->NewRandomAccessFile(fname, &file));
string line;
io::InputBuffer in(file.get(), buf_size);
TF_CHECK_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line one");
TF_CHECK_OK(in.ReadLine(&line));
EXPECT_EQ(line, "");
TF_CHECK_OK(in.ReadLine(&line));
EXPECT_EQ(line, "");
TF_CHECK_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line two");
TF_CHECK_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line three");
EXPECT_TRUE(errors::IsOutOfRange(in.ReadLine(&line)));
EXPECT_TRUE(errors::IsOutOfRange(in.ReadLine(&line)));
}
}
TEST(InputBuffer, ReadLine_CRLF) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(WriteStringToFile(env, fname,
"line one\r\n\r\n\r\nline two\r\nline three"));
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessFile> file;
TF_CHECK_OK(env->NewRandomAccessFile(fname, &file));
string line;
io::InputBuffer in(file.get(), buf_size);
TF_CHECK_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line one");
TF_CHECK_OK(in.ReadLine(&line));
EXPECT_EQ(line, "");
TF_CHECK_OK(in.ReadLine(&line));
EXPECT_EQ(line, "");
TF_CHECK_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line two");
TF_CHECK_OK(in.ReadLine(&line));
EXPECT_EQ(line, "line three");
EXPECT_TRUE(errors::IsOutOfRange(in.ReadLine(&line)));
EXPECT_TRUE(errors::IsOutOfRange(in.ReadLine(&line)));
}
}
TEST(InputBuffer, ReadNBytes) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(WriteStringToFile(env, fname, "0123456789"));
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessFile> file;
TF_CHECK_OK(env->NewRandomAccessFile(fname, &file));
string read;
io::InputBuffer in(file.get(), buf_size);
EXPECT_EQ(0, in.Tell());
TF_CHECK_OK(in.ReadNBytes(3, &read));
EXPECT_EQ(read, "012");
EXPECT_EQ(3, in.Tell());
TF_CHECK_OK(in.ReadNBytes(0, &read));
EXPECT_EQ(read, "");
EXPECT_EQ(3, in.Tell());
TF_CHECK_OK(in.ReadNBytes(4, &read));
EXPECT_EQ(read, "3456");
EXPECT_EQ(7, in.Tell());
TF_CHECK_OK(in.ReadNBytes(0, &read));
EXPECT_EQ(read, "");
EXPECT_EQ(7, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.ReadNBytes(5, &read)));
EXPECT_EQ(read, "789");
EXPECT_EQ(10, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.ReadNBytes(5, &read)));
EXPECT_EQ(read, "");
EXPECT_EQ(10, in.Tell());
TF_CHECK_OK(in.ReadNBytes(0, &read));
EXPECT_EQ(read, "");
EXPECT_EQ(10, in.Tell());
}
size_t bytes_read;
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessFile> file;
TF_CHECK_OK(env->NewRandomAccessFile(fname, &file));
char read[5];
io::InputBuffer in(file.get(), buf_size);
EXPECT_EQ(0, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(3, read, &bytes_read));
EXPECT_EQ(StringPiece(read, 3), "012");
EXPECT_EQ(3, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(0, read, &bytes_read));
EXPECT_EQ(StringPiece(read, 3), "012");
EXPECT_EQ(3, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(4, read, &bytes_read));
EXPECT_EQ(StringPiece(read, 4), "3456");
EXPECT_EQ(7, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(0, read, &bytes_read));
EXPECT_EQ(StringPiece(read, 4), "3456");
EXPECT_EQ(7, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.ReadNBytes(5, read, &bytes_read)));
EXPECT_EQ(StringPiece(read, 3), "789");
EXPECT_EQ(10, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.ReadNBytes(5, read, &bytes_read)));
EXPECT_EQ(StringPiece(read, 3), "789");
EXPECT_EQ(10, in.Tell());
TF_ASSERT_OK(in.ReadNBytes(0, read, &bytes_read));
EXPECT_EQ(StringPiece(read, 3), "789");
EXPECT_EQ(10, in.Tell());
}
}
TEST(InputBuffer, SkipNBytes) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(WriteStringToFile(env, fname, "0123456789"));
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessFile> file;
TF_CHECK_OK(env->NewRandomAccessFile(fname, &file));
string read;
io::InputBuffer in(file.get(), buf_size);
EXPECT_EQ(0, in.Tell());
TF_CHECK_OK(in.SkipNBytes(3));
EXPECT_EQ(3, in.Tell());
TF_CHECK_OK(in.SkipNBytes(0));
EXPECT_EQ(3, in.Tell());
TF_CHECK_OK(in.ReadNBytes(2, &read));
EXPECT_EQ(read, "34");
EXPECT_EQ(5, in.Tell());
TF_CHECK_OK(in.SkipNBytes(0));
EXPECT_EQ(5, in.Tell());
TF_CHECK_OK(in.SkipNBytes(2));
EXPECT_EQ(7, in.Tell());
TF_CHECK_OK(in.ReadNBytes(1, &read));
EXPECT_EQ(read, "7");
EXPECT_EQ(8, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.SkipNBytes(5)));
EXPECT_EQ(10, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.SkipNBytes(5)));
EXPECT_EQ(10, in.Tell());
EXPECT_TRUE(errors::IsOutOfRange(in.ReadNBytes(5, &read)));
EXPECT_EQ(read, "");
EXPECT_EQ(10, in.Tell());
}
}
TEST(InputBuffer, Seek) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(WriteStringToFile(env, fname, "0123456789"));
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessFile> file;
TF_CHECK_OK(env->NewRandomAccessFile(fname, &file));
string read;
io::InputBuffer in(file.get(), buf_size);
TF_CHECK_OK(in.ReadNBytes(3, &read));
EXPECT_EQ(read, "012");
TF_CHECK_OK(in.ReadNBytes(3, &read));
EXPECT_EQ(read, "345");
TF_CHECK_OK(in.Seek(0));
TF_CHECK_OK(in.ReadNBytes(3, &read));
EXPECT_EQ(read, "012");
TF_CHECK_OK(in.Seek(3));
TF_CHECK_OK(in.ReadNBytes(4, &read));
EXPECT_EQ(read, "3456");
TF_CHECK_OK(in.Seek(4));
TF_CHECK_OK(in.ReadNBytes(4, &read));
EXPECT_EQ(read, "4567");
TF_CHECK_OK(in.Seek(1 << 25));
EXPECT_TRUE(errors::IsOutOfRange(in.ReadNBytes(1, &read)));
EXPECT_TRUE(absl::StrContains(in.Seek(-1).ToString(), "negative position"));
}
}
TEST(InputBuffer, ReadVarint32) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
std::vector<uint32> data;
uint32 i = 0;
for (; i < (1U << 10); i += 1) data.push_back(i);
for (; i < (1U << 15); i += 5) data.push_back(i);
for (; i < (1U << 31); i += 132817) data.push_back(i);
data.push_back(std::numeric_limits<uint32>::max());
{
std::unique_ptr<WritableFile> file;
TF_CHECK_OK(env->NewWritableFile(fname, &file));
string varint;
for (uint32 number : data) {
varint.clear();
core::PutVarint32(&varint, number);
TF_CHECK_OK(file->Append(StringPiece(varint)));
}
}
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessFile> file;
TF_CHECK_OK(env->NewRandomAccessFile(fname, &file));
io::InputBuffer in(file.get(), buf_size);
uint32 result = 0;
for (uint32 expected : data) {
TF_ASSERT_OK(in.ReadVarint32(&result));
EXPECT_EQ(expected, result);
}
EXPECT_TRUE(errors::IsOutOfRange(in.ReadVarint32(&result)));
}
}
TEST(InputBuffer, ReadVarint64) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
std::vector<uint64> data;
uint64 i = 0;
for (; i < (1U << 10); i += 1) data.push_back(i);
for (; i < (1U << 15); i += 5) data.push_back(i);
for (; i < (1U << 31); i += 164817) data.push_back(i);
for (; i < (1ULL << 63); i += 16481797854795663UL) data.push_back(i);
data.push_back(std::numeric_limits<uint64>::max());
{
std::unique_ptr<WritableFile> file;
TF_CHECK_OK(env->NewWritableFile(fname, &file));
string varint;
for (uint64 number : data) {
varint.clear();
core::PutVarint64(&varint, number);
TF_CHECK_OK(file->Append(StringPiece(varint)));
}
}
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessFile> file;
TF_CHECK_OK(env->NewRandomAccessFile(fname, &file));
io::InputBuffer in(file.get(), buf_size);
uint64 result = 0;
for (uint64 expected : data) {
TF_ASSERT_OK(in.ReadVarint64(&result));
EXPECT_EQ(expected, result);
}
EXPECT_TRUE(errors::IsOutOfRange(in.ReadVarint64(&result)));
}
}
TEST(InputBuffer, Hint) {
Env* env = Env::Default();
string fname;
ASSERT_TRUE(env->LocalTempFilename(&fname));
TF_ASSERT_OK(WriteStringToFile(env, fname, "0123456789"));
for (auto buf_size : BufferSizes()) {
std::unique_ptr<RandomAccessFile> file;
TF_CHECK_OK(env->NewRandomAccessFile(fname, &file));
string read;
io::InputBuffer in(file.get(), buf_size);
TF_CHECK_OK(in.ReadNBytes(3, &read));
EXPECT_EQ(read, "012");
TF_CHECK_OK(in.Hint(4));
TF_CHECK_OK(in.ReadNBytes(3, &read));
EXPECT_EQ(read, "345");
TF_CHECK_OK(in.Hint(1));
TF_CHECK_OK(in.ReadNBytes(3, &read));
EXPECT_EQ(read, "678");
TF_CHECK_OK(in.Seek(0));
TF_CHECK_OK(in.Hint(7));
TF_CHECK_OK(in.ReadNBytes(3, &read));
EXPECT_EQ(read, "012");
TF_CHECK_OK(in.ReadNBytes(4, &read));
EXPECT_EQ(read, "3456");
TF_CHECK_OK(in.Hint(2));
TF_CHECK_OK(in.Seek(4));
TF_CHECK_OK(in.ReadNBytes(4, &read));
EXPECT_EQ(read, "4567");
TF_CHECK_OK(in.Seek(0));
TF_CHECK_OK(in.Hint(1 << 25));
TF_CHECK_OK(in.Seek(1 << 25));
EXPECT_TRUE(errors::IsOutOfRange(in.Hint(1)));
EXPECT_TRUE(errors::IsInvalidArgument(in.Hint(-1)));
}
}
}
} |
2,651 | cpp | google/tsl | cache | tsl/lib/io/cache.cc | tsl/lib/io/cache_test.cc | #ifndef TENSORFLOW_TSL_LIB_IO_CACHE_H_
#define TENSORFLOW_TSL_LIB_IO_CACHE_H_
#include <cstdint>
#include "tsl/platform/stringpiece.h"
namespace tsl {
using Slice = StringPiece;
namespace table {
class Cache;
Cache* NewLRUCache(size_t capacity);
class Cache {
public:
Cache() = default;
Cache(const Cache&) = delete;
Cache& operator=(const Cache&) = delete;
virtual ~Cache();
struct Handle {};
virtual Handle* Insert(const Slice& key, void* value, size_t charge,
void (*deleter)(const Slice& key, void* value)) = 0;
virtual Handle* Lookup(const Slice& key) = 0;
virtual void Release(Handle* handle) = 0;
virtual void* Value(Handle* handle) = 0;
virtual void Erase(const Slice& key) = 0;
virtual uint64_t NewId() = 0;
virtual void Prune() {}
virtual size_t TotalCharge() const = 0;
private:
void LRU_Remove(Handle* e);
void LRU_Append(Handle* e);
void Unref(Handle* e);
struct Rep;
Rep* rep_;
};
}
}
#endif
#include "tsl/lib/io/cache.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "tsl/platform/mutex.h"
#include "tsl/platform/raw_coding.h"
namespace tsl {
namespace table {
Cache::~Cache() {}
namespace {
struct LRUHandle {
void* value;
void (*deleter)(const Slice&, void* value);
LRUHandle* next_hash;
LRUHandle* next;
LRUHandle* prev;
size_t charge;
size_t key_length;
bool in_cache;
uint32_t refs;
uint32_t hash;
char key_data[1];
Slice key() const {
assert(next != this);
return Slice(key_data, key_length);
}
};
class HandleTable {
public:
HandleTable() : length_(0), elems_(0), list_(nullptr) { Resize(); }
~HandleTable() { delete[] list_; }
LRUHandle* Lookup(const Slice& key, uint32_t hash) {
return *FindPointer(key, hash);
}
LRUHandle* Insert(LRUHandle* h) {
LRUHandle** ptr = FindPointer(h->key(), h->hash);
LRUHandle* old = *ptr;
h->next_hash = (old == nullptr ? nullptr : old->next_hash);
*ptr = h;
if (old == nullptr) {
++elems_;
if (elems_ > length_) {
Resize();
}
}
return old;
}
LRUHandle* Remove(const Slice& key, uint32_t hash) {
LRUHandle** ptr = FindPointer(key, hash);
LRUHandle* result = *ptr;
if (result != nullptr) {
*ptr = result->next_hash;
--elems_;
}
return result;
}
private:
uint32_t length_;
uint32_t elems_;
LRUHandle** list_;
LRUHandle** FindPointer(const Slice& key, uint32_t hash) {
LRUHandle** ptr = &list_[hash & (length_ - 1)];
while (*ptr != nullptr && ((*ptr)->hash != hash || key != (*ptr)->key())) {
ptr = &(*ptr)->next_hash;
}
return ptr;
}
void Resize() {
uint32_t new_length = 4;
while (new_length < elems_) {
new_length *= 2;
}
LRUHandle** new_list = new LRUHandle*[new_length];
memset(new_list, 0, sizeof(new_list[0]) * new_length);
uint32_t count = 0;
for (uint32_t i = 0; i < length_; i++) {
LRUHandle* h = list_[i];
while (h != nullptr) {
LRUHandle* next = h->next_hash;
uint32_t hash = h->hash;
LRUHandle** ptr = &new_list[hash & (new_length - 1)];
h->next_hash = *ptr;
*ptr = h;
h = next;
count++;
}
}
assert(elems_ == count);
delete[] list_;
list_ = new_list;
length_ = new_length;
}
};
class LRUCache {
public:
LRUCache();
~LRUCache();
void SetCapacity(size_t capacity) { capacity_ = capacity; }
Cache::Handle* Insert(const Slice& key, uint32_t hash, void* value,
size_t charge,
void (*deleter)(const Slice& key, void* value));
Cache::Handle* Lookup(const Slice& key, uint32_t hash);
void Release(Cache::Handle* handle);
void Erase(const Slice& key, uint32_t hash);
void Prune();
size_t TotalCharge() const {
mutex_lock l(mutex_);
return usage_;
}
private:
void LRU_Remove(LRUHandle* e);
void LRU_Append(LRUHandle* list, LRUHandle* e);
void Ref(LRUHandle* e);
void Unref(LRUHandle* e);
bool FinishErase(LRUHandle* e) TF_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
size_t capacity_;
mutable mutex mutex_;
size_t usage_ TF_GUARDED_BY(mutex_);
LRUHandle lru_ TF_GUARDED_BY(mutex_);
LRUHandle in_use_ TF_GUARDED_BY(mutex_);
HandleTable table_ TF_GUARDED_BY(mutex_);
};
LRUCache::LRUCache() : capacity_(0), usage_(0) {
lru_.next = &lru_;
lru_.prev = &lru_;
in_use_.next = &in_use_;
in_use_.prev = &in_use_;
}
LRUCache::~LRUCache() {
assert(in_use_.next == &in_use_);
for (LRUHandle* e = lru_.next; e != &lru_;) {
LRUHandle* next = e->next;
assert(e->in_cache);
e->in_cache = false;
assert(e->refs == 1);
Unref(e);
e = next;
}
}
void LRUCache::Ref(LRUHandle* e) {
if (e->refs == 1 && e->in_cache) {
LRU_Remove(e);
LRU_Append(&in_use_, e);
}
e->refs++;
}
void LRUCache::Unref(LRUHandle* e) {
assert(e->refs > 0);
e->refs--;
if (e->refs == 0) {
assert(!e->in_cache);
(*e->deleter)(e->key(), e->value);
free(e);
} else if (e->in_cache && e->refs == 1) {
LRU_Remove(e);
LRU_Append(&lru_, e);
}
}
void LRUCache::LRU_Remove(LRUHandle* e) {
e->next->prev = e->prev;
e->prev->next = e->next;
}
void LRUCache::LRU_Append(LRUHandle* list, LRUHandle* e) {
e->next = list;
e->prev = list->prev;
e->prev->next = e;
e->next->prev = e;
}
Cache::Handle* LRUCache::Lookup(const Slice& key, uint32_t hash) {
mutex_lock l(mutex_);
LRUHandle* e = table_.Lookup(key, hash);
if (e != nullptr) {
Ref(e);
}
return reinterpret_cast<Cache::Handle*>(e);
}
void LRUCache::Release(Cache::Handle* handle) {
mutex_lock l(mutex_);
Unref(reinterpret_cast<LRUHandle*>(handle));
}
Cache::Handle* LRUCache::Insert(const Slice& key, uint32_t hash, void* value,
size_t charge,
void (*deleter)(const Slice& key,
void* value)) {
mutex_lock l(mutex_);
LRUHandle* e =
reinterpret_cast<LRUHandle*>(malloc(sizeof(LRUHandle) - 1 + key.size()));
e->value = value;
e->deleter = deleter;
e->charge = charge;
e->key_length = key.size();
e->hash = hash;
e->in_cache = false;
e->refs = 1;
memcpy(e->key_data, key.data(), key.size());
if (capacity_ > 0) {
e->refs++;
e->in_cache = true;
LRU_Append(&in_use_, e);
usage_ += charge;
FinishErase(table_.Insert(e));
} else {
e->next = nullptr;
}
while (usage_ > capacity_ && lru_.next != &lru_) {
LRUHandle* old = lru_.next;
assert(old->refs == 1);
bool erased = FinishErase(table_.Remove(old->key(), old->hash));
if (!erased) {
assert(erased);
}
}
return reinterpret_cast<Cache::Handle*>(e);
}
bool LRUCache::FinishErase(LRUHandle* e) {
if (e != nullptr) {
assert(e->in_cache);
LRU_Remove(e);
e->in_cache = false;
usage_ -= e->charge;
Unref(e);
}
return e != nullptr;
}
void LRUCache::Erase(const Slice& key, uint32_t hash) {
mutex_lock l(mutex_);
FinishErase(table_.Remove(key, hash));
}
void LRUCache::Prune() {
mutex_lock l(mutex_);
while (lru_.next != &lru_) {
LRUHandle* e = lru_.next;
assert(e->refs == 1);
bool erased = FinishErase(table_.Remove(e->key(), e->hash));
if (!erased) {
assert(erased);
}
}
}
static const int kNumShardBits = 4;
static const int kNumShards = 1 << kNumShardBits;
class ShardedLRUCache : public Cache {
private:
LRUCache shard_[kNumShards];
mutex id_mutex_;
uint64_t last_id_;
static inline uint32_t HashSlice(const Slice& s) {
return Hash(s.data(), s.size(), 0);
}
static uint32_t Shard(uint32_t hash) { return hash >> (32 - kNumShardBits); }
public:
explicit ShardedLRUCache(size_t capacity) : last_id_(0) {
const size_t per_shard = (capacity + (kNumShards - 1)) / kNumShards;
for (int s = 0; s < kNumShards; s++) {
shard_[s].SetCapacity(per_shard);
}
}
~ShardedLRUCache() override {}
Handle* Insert(const Slice& key, void* value, size_t charge,
void (*deleter)(const Slice& key, void* value)) override {
const uint32_t hash = HashSlice(key);
return shard_[Shard(hash)].Insert(key, hash, value, charge, deleter);
}
Handle* Lookup(const Slice& key) override {
const uint32_t hash = HashSlice(key);
return shard_[Shard(hash)].Lookup(key, hash);
}
void Release(Handle* handle) override {
LRUHandle* h = reinterpret_cast<LRUHandle*>(handle);
shard_[Shard(h->hash)].Release(handle);
}
void Erase(const Slice& key) override {
const uint32_t hash = HashSlice(key);
shard_[Shard(hash)].Erase(key, hash);
}
void* Value(Handle* handle) override {
return reinterpret_cast<LRUHandle*>(handle)->value;
}
uint64_t NewId() override {
mutex_lock l(id_mutex_);
return ++(last_id_);
}
void Prune() override {
for (int s = 0; s < kNumShards; s++) {
shard_[s].Prune();
}
}
size_t TotalCharge() const override {
size_t total = 0;
for (int s = 0; s < kNumShards; s++) {
total += shard_[s].TotalCharge();
}
return total;
}
private:
static uint32_t Hash(const char* data, size_t n, uint32_t seed) {
const uint32_t m = 0xc6a4a793;
const uint32_t r = 24;
const char* limit = data + n;
uint32_t h = seed ^ (n * m);
while (data + 4 <= limit) {
uint32_t w = core::DecodeFixed32(data);
data += 4;
h += w;
h *= m;
h ^= (h >> 16);
}
switch (limit - data) {
case 3:
h += static_cast<uint8_t>(data[2]) << 16;
ABSL_FALLTHROUGH_INTENDED;
case 2:
h += static_cast<uint8_t>(data[1]) << 8;
ABSL_FALLTHROUGH_INTENDED;
case 1:
h += static_cast<uint8_t>(data[0]);
h *= m;
h ^= (h >> r);
break;
}
return h;
}
};
}
Cache* NewLRUCache(size_t capacity) { return new ShardedLRUCache(capacity); }
}
} | #include "tsl/lib/io/cache.h"
#include <string>
#include <vector>
#include "tsl/platform/coding.h"
#include "tsl/platform/raw_coding.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace table {
static std::string EncodeKey(int k) {
std::string result;
core::PutFixed32(&result, k);
return result;
}
static int DecodeKey(const Slice& k) {
assert(k.size() == 4);
return core::DecodeFixed32(k.data());
}
static void* EncodeValue(uintptr_t v) { return reinterpret_cast<void*>(v); }
static int DecodeValue(void* v) { return reinterpret_cast<uintptr_t>(v); }
class CacheTest : public ::testing::Test {
public:
static void Deleter(const Slice& key, void* v) {
current_->deleted_keys_.push_back(DecodeKey(key));
current_->deleted_values_.push_back(DecodeValue(v));
}
static constexpr int kCacheSize = 1000;
std::vector<int> deleted_keys_;
std::vector<int> deleted_values_;
Cache* cache_;
CacheTest() : cache_(NewLRUCache(kCacheSize)) { current_ = this; }
~CacheTest() { delete cache_; }
int Lookup(int key) {
Cache::Handle* handle = cache_->Lookup(EncodeKey(key));
const int r = (handle == nullptr) ? -1 : DecodeValue(cache_->Value(handle));
if (handle != nullptr) {
cache_->Release(handle);
}
return r;
}
void Insert(int key, int value, int charge = 1) {
cache_->Release(cache_->Insert(EncodeKey(key), EncodeValue(value), charge,
&CacheTest::Deleter));
}
Cache::Handle* InsertAndReturnHandle(int key, int value, int charge = 1) {
return cache_->Insert(EncodeKey(key), EncodeValue(value), charge,
&CacheTest::Deleter);
}
void Erase(int key) { cache_->Erase(EncodeKey(key)); }
static CacheTest* current_;
};
CacheTest* CacheTest::current_;
TEST_F(CacheTest, HitAndMiss) {
ASSERT_EQ(-1, Lookup(100));
Insert(100, 101);
ASSERT_EQ(101, Lookup(100));
ASSERT_EQ(-1, Lookup(200));
ASSERT_EQ(-1, Lookup(300));
Insert(200, 201);
ASSERT_EQ(101, Lookup(100));
ASSERT_EQ(201, Lookup(200));
ASSERT_EQ(-1, Lookup(300));
Insert(100, 102);
ASSERT_EQ(102, Lookup(100));
ASSERT_EQ(201, Lookup(200));
ASSERT_EQ(-1, Lookup(300));
ASSERT_EQ(1, deleted_keys_.size());
ASSERT_EQ(100, deleted_keys_[0]);
ASSERT_EQ(101, deleted_values_[0]);
}
TEST_F(CacheTest, Erase) {
Erase(200);
ASSERT_EQ(0, deleted_keys_.size());
Insert(100, 101);
Insert(200, 201);
Erase(100);
ASSERT_EQ(-1, Lookup(100));
ASSERT_EQ(201, Lookup(200));
ASSERT_EQ(1, deleted_keys_.size());
ASSERT_EQ(100, deleted_keys_[0]);
ASSERT_EQ(101, deleted_values_[0]);
Erase(100);
ASSERT_EQ(-1, Lookup(100));
ASSERT_EQ(201, Lookup(200));
ASSERT_EQ(1, deleted_keys_.size());
}
TEST_F(CacheTest, EntriesArePinned) {
Insert(100, 101);
Cache::Handle* h1 = cache_->Lookup(EncodeKey(100));
ASSERT_EQ(101, DecodeValue(cache_->Value(h1)));
Insert(100, 102);
Cache::Handle* h2 = cache_->Lookup(EncodeKey(100));
ASSERT_EQ(102, DecodeValue(cache_->Value(h2)));
ASSERT_EQ(0, deleted_keys_.size());
cache_->Release(h1);
ASSERT_EQ(1, deleted_keys_.size());
ASSERT_EQ(100, deleted_keys_[0]);
ASSERT_EQ(101, deleted_values_[0]);
Erase(100);
ASSERT_EQ(-1, Lookup(100));
ASSERT_EQ(1, deleted_keys_.size());
cache_->Release(h2);
ASSERT_EQ(2, deleted_keys_.size());
ASSERT_EQ(100, deleted_keys_[1]);
ASSERT_EQ(102, deleted_values_[1]);
}
TEST_F(CacheTest, EvictionPolicy) {
Insert(100, 101);
Insert(200, 201);
Insert(300, 301);
Cache::Handle* h = cache_->Lookup(EncodeKey(300));
for (int i = 0; i < kCacheSize + 100; i++) {
Insert(1000 + i, 2000 + i);
ASSERT_EQ(2000 + i, Lookup(1000 + i));
ASSERT_EQ(101, Lookup(100));
}
ASSERT_EQ(101, Lookup(100));
ASSERT_EQ(-1, Lookup(200));
ASSERT_EQ(301, Lookup(300));
cache_->Release(h);
}
TEST_F(CacheTest, UseExceedsCacheSize) {
std::vector<Cache::Handle*> h;
for (int i = 0; i < kCacheSize + 100; i++) {
h.push_back(InsertAndReturnHandle(1000 + i, 2000 + i));
}
for (int i = 0; i < h.size(); i++) {
ASSERT_EQ(2000 + i, Lookup(1000 + i));
}
for (int i = 0; i < h.size(); i++) {
cache_->Release(h[i]);
}
}
TEST_F(CacheTest, HeavyEntries) {
const int kLight = 1;
const int kHeavy = 10;
int added = 0;
int index = 0;
while (added < 2 * kCacheSize) {
const int weight = (index & 1) ? kLight : kHeavy;
Insert(index, 1000 + index, weight);
added += weight;
index++;
}
int cached_weight = 0;
for (int i = 0; i < index; i++) {
const int weight = (i & 1 ? kLight : kHeavy);
int r = Lookup(i);
if (r >= 0) {
cached_weight += weight;
ASSERT_EQ(1000 + i, r);
}
}
ASSERT_LE(cached_weight, kCacheSize + kCacheSize / 10);
}
TEST_F(CacheTest, NewId) {
uint64_t a = cache_->NewId();
uint64_t b = cache_->NewId();
ASSERT_NE(a, b);
}
TEST_F(CacheTest, Prune) {
Insert(1, 100);
Insert(2, 200);
Cache::Handle* handle = cache_->Lookup(EncodeKey(1));
ASSERT_TRUE(handle);
cache_->Prune();
cache_->Release(handle);
ASSERT_EQ(100, Lookup(1));
ASSERT_EQ(-1, Lookup(2));
}
TEST_F(CacheTest, ZeroSizeCache) {
delete cache_;
cache_ = NewLRUCache(0);
Insert(1, 100);
ASSERT_EQ(-1, Lookup(1));
}
}
} |
2,652 | cpp | google/tsl | inputstream_interface | tsl/lib/io/inputstream_interface.cc | tsl/lib/io/inputstream_interface_test.cc | #ifndef TENSORFLOW_TSL_LIB_IO_INPUTSTREAM_INTERFACE_H_
#define TENSORFLOW_TSL_LIB_IO_INPUTSTREAM_INTERFACE_H_
#include <string>
#include "tsl/platform/cord.h"
#include "tsl/platform/errors.h"
#include "tsl/platform/status.h"
#include "tsl/platform/types.h"
namespace tsl {
namespace io {
class InputStreamInterface {
public:
InputStreamInterface() {}
virtual ~InputStreamInterface() {}
virtual absl::Status ReadNBytes(int64_t bytes_to_read, tstring* result) = 0;
#if defined(TF_CORD_SUPPORT)
virtual absl::Status ReadNBytes(int64_t bytes_to_read, absl::Cord* cord) {
return errors::Unimplemented(
"ReadNBytes(int64, absl::Cord*) is not implemented.");
}
#endif
virtual absl::Status SkipNBytes(int64_t bytes_to_skip);
virtual int64_t Tell() const = 0;
virtual absl::Status Reset() = 0;
};
}
}
#endif
#include "tsl/lib/io/inputstream_interface.h"
#include "tsl/platform/errors.h"
namespace tsl {
namespace io {
static constexpr int64_t kMaxSkipSize = 8 * 1024 * 1024;
absl::Status InputStreamInterface::SkipNBytes(int64_t bytes_to_skip) {
if (bytes_to_skip < 0) {
return errors::InvalidArgument("Can't skip a negative number of bytes");
}
tstring unused;
while (bytes_to_skip > 0) {
int64_t bytes_to_read = std::min<int64_t>(kMaxSkipSize, bytes_to_skip);
TF_RETURN_IF_ERROR(ReadNBytes(bytes_to_read, &unused));
bytes_to_skip -= bytes_to_read;
}
return absl::OkStatus();
}
}
} | #include "tsl/lib/io/inputstream_interface.h"
#include "tsl/lib/core/status_test_util.h"
#include "tsl/platform/errors.h"
#include "tsl/platform/test.h"
namespace tsl {
namespace io {
namespace {
class TestStringStream : public InputStreamInterface {
public:
explicit TestStringStream(const string& content) : content_(content) {}
absl::Status ReadNBytes(int64_t bytes_to_read, tstring* result) override {
result->clear();
if (pos_ + bytes_to_read > content_.size()) {
return errors::OutOfRange("limit reached");
}
*result = content_.substr(pos_, bytes_to_read);
pos_ += bytes_to_read;
return absl::OkStatus();
}
int64_t Tell() const override { return pos_; }
absl::Status Reset() override {
pos_ = 0;
return absl::OkStatus();
}
private:
string content_;
int64_t pos_ = 0;
};
TEST(InputStreamInterface, Basic) {
TestStringStream ss("This is a test string");
tstring res;
TF_ASSERT_OK(ss.ReadNBytes(4, &res));
EXPECT_EQ("This", res);
TF_ASSERT_OK(ss.SkipNBytes(6));
TF_ASSERT_OK(ss.ReadNBytes(11, &res));
EXPECT_EQ("test string", res);
EXPECT_TRUE(errors::IsOutOfRange(ss.SkipNBytes(1)));
TF_ASSERT_OK(ss.Reset());
TF_ASSERT_OK(ss.ReadNBytes(4, &res));
EXPECT_EQ("This", res);
}
}
}
} |
1 | cpp | cpputest | AllTestsForTarget.cpp | platforms/CCStudio/tests/CppUTestExt/AllTestsForTarget.cpp | null | /*
* Copyright (c) 2013, Michael Feathers, James Grenning, Bas Vodde
* and Arnd Strube
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/CommandLineTestRunner.h"
#include "CppUTest/TestRegistry.h"
#include "CppUTestExt/MemoryReporterPlugin.h"
#include "CppUTestExt/MockSupportPlugin.h"
int main(int ac, char** av)
{
/* Specify commandline arguments here as needed */
char* argv[] =
{
(char*) 0,
(char*) "-v",
// (char*) "-gSimpleStringBuffer",
// (char*) "-ojunit",
};
ac = sizeof(argv) / sizeof(char*);
MemoryReporterPlugin plugin;
MockSupportPlugin mockPlugin;
TestRegistry::getCurrentRegistry()->installPlugin(&plugin);
TestRegistry::getCurrentRegistry()->installPlugin(&mockPlugin);
return CommandLineTestRunner::RunAllTests(ac, argv);
}
| null |
2 | cpp | cpputest | AllTestsForTarget.cpp | platforms/CCStudio/tests/CppUTest/AllTestsForTarget.cpp | null | /*
* Copyright (c) 2013, Michael Feathers, James Grenning, Bas Vodde
* and Arnd Strube
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/CommandLineTestRunner.h"
int main(int ac, char** av)
{
/* Specify commandline arguments here as needed */
char* argv[] =
{
(char*) 0,
(char*) "-v",
// (char*) "-gSimpleStringBuffer",
// (char*) "-ojunit",
};
ac = sizeof(argv) / sizeof(char*);
/* These checks are here to make sure assertions outside test runs don't crash */
CHECK(true);
LONGS_EQUAL(1, 1);
return CommandLineTestRunner::RunAllTests(ac, argv);
}
| null |
3 | cpp | cpputest | EventDispatcher.cpp | examples/ApplicationLib/EventDispatcher.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "EventDispatcher.h"
using namespace std;
EventDispatcher::EventDispatcher() {}
void EventDispatcher::registerObserver(EventType type, EventObserver* observer)
{
for (list<pair<EventType, EventObserver*> >::iterator i = observerList_.begin(); i != observerList_.end(); i++)
i->second->notifyRegistration(observer);
observerList_.push_back(make_pair(type, observer));
}
void EventDispatcher::dispatchEvent(const Event& event, int timeoutSeconds)
{
for (list<pair<EventType, EventObserver*> >::iterator i = observerList_.begin(); i != observerList_.end(); i++) {
if (i->first == event.type)
i->second->notify(event, timeoutSeconds);
}
}
| null |
4 | cpp | cpputest | Printer.cpp | examples/ApplicationLib/Printer.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "Printer.h"
#include <stdio.h>
Printer::Printer() {}
Printer::~Printer() {}
void Printer::Print(const char* s)
{
for (const char* p = s; *p; p++)
putchar(*p);
}
void Printer::Print(long int n)
{
printf("%ld", n);
}
Printer& operator<<(Printer& p, const char* s)
{
p.Print(s);
return p;
}
Printer& operator<<(Printer& p, long int i)
{
p.Print(i);
return p;
}
| null |
5 | cpp | cpputest | hello.h | examples/ApplicationLib/hello.h | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef HELLO_H_
#define HELLO_H_
#ifdef __cplusplus
extern "C" {
#endif
extern void printHelloWorld(void);
extern int (*PrintFormated)(const char*, ...);
#ifdef __cplusplus
}
#endif
#endif /*HELLO_H_*/
| null |
6 | cpp | cpputest | EventDispatcher.h | examples/ApplicationLib/EventDispatcher.h | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef EVENTDISPATCHER_H
#define EVENTDISPATCHER_H
#include <list>
enum EventType
{
IMPORTANT_EVENT,
LESS_IMPORTANT_EVENT
};
class Event
{
public:
EventType type;
};
class EventObserver
{
public:
virtual void notify(const Event& event, int timeOutInSeconds) = 0;
virtual void notifyRegistration(EventObserver* newObserver) = 0;
virtual ~EventObserver() {}
};
class EventDispatcher
{
std::list<std::pair<EventType, EventObserver*> > observerList_;
public:
EventDispatcher();
void registerObserver(EventType type, EventObserver* observer);
void dispatchEvent(const Event& event, int timeoutSeconds);
};
#endif
| null |
7 | cpp | cpputest | CircularBuffer.cpp | examples/ApplicationLib/CircularBuffer.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CircularBuffer.h"
#include "Printer.h"
#include <stddef.h>
CircularBuffer::CircularBuffer(int _capacity) : index(0), outdex(0), capacity(_capacity), empty(true), full(false)
{
buffer = new int[(size_t)this->capacity];
}
CircularBuffer::~CircularBuffer()
{
delete[] buffer;
}
bool CircularBuffer::IsEmpty()
{
return empty;
}
bool CircularBuffer::IsFull()
{
return full;
}
void CircularBuffer::Put(int i)
{
empty = false;
buffer[index] = i;
index = Next(index);
if (full)
outdex = Next(outdex);
else if (index == outdex)
full = true;
}
int CircularBuffer::Get()
{
int result = -1;
full = false;
if (!empty) {
result = buffer[outdex];
outdex = Next(outdex);
if (outdex == index)
empty = true;
}
return result;
}
int CircularBuffer::Capacity()
{
return capacity;
}
int CircularBuffer::Next(int i)
{
if (++i >= capacity)
i = 0;
return i;
}
void CircularBuffer::Print(Printer* p)
{
p->Print("Circular buffer content:\n<");
int printIndex = outdex;
int count = index - outdex;
if (!empty && (index <= outdex))
count = capacity - (outdex - index);
for (int i = 0; i < count; i++) {
p->Print(buffer[printIndex]);
printIndex = Next(printIndex);
if (i + 1 != count)
p->Print(", ");
}
p->Print(">\n");
}
| null |
8 | cpp | cpputest | ExamplesNewOverrides.h | examples/ApplicationLib/ExamplesNewOverrides.h | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <list>
#include "CppUTest/MemoryLeakDetectorNewMacros.h"
| null |
9 | cpp | cpputest | Printer.h | examples/ApplicationLib/Printer.h | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef D_Printer_H
#define D_Printer_H
///////////////////////////////////////////////////////////////////////////////
//
// Printer is responsible for ...
//
///////////////////////////////////////////////////////////////////////////////
class Printer
{
public:
explicit Printer();
virtual ~Printer();
virtual void Print(const char*);
virtual void Print(long int);
private:
Printer(const Printer&);
Printer& operator=(const Printer&);
};
Printer& operator<<(Printer&, const char*);
Printer& operator<<(Printer&, long int);
#endif // D_Printer_H
| null |
10 | cpp | cpputest | CircularBuffer.h | examples/ApplicationLib/CircularBuffer.h | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef D_CircularBuffer_H
#define D_CircularBuffer_H
///////////////////////////////////////////////////////////////////////////////
//
// CircularBuffer.h
//
// CircularBuffer is responsible for ...
//
///////////////////////////////////////////////////////////////////////////////
class Printer;
class CircularBuffer
{
public:
explicit CircularBuffer(int capacity = CAPACITY);
virtual ~CircularBuffer();
void Put(int);
int Get();
bool IsEmpty();
bool IsFull();
int Capacity();
int Next(int i);
void Print(Printer*);
private:
int index;
int outdex;
int* buffer;
int capacity;
enum
{
CAPACITY = 5
};
bool empty;
bool full;
CircularBuffer(const CircularBuffer&);
CircularBuffer& operator=(const CircularBuffer&);
};
#endif // D_CircularBuffer_H
| null |
11 | cpp | cpputest | PrinterTest.cpp | examples/AllTests/PrinterTest.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/TestHarness.h"
#include "Printer.h"
#include "MockPrinter.h"
TEST_GROUP(Printer)
{
Printer* printer;
MockPrinter* mockPrinter;
void setup() CPPUTEST_OVERRIDE
{
mockPrinter = new MockPrinter();
printer = mockPrinter;
}
void teardown() CPPUTEST_OVERRIDE
{
delete printer;
}
};
TEST(Printer, PrintConstCharStar)
{
printer->Print("hello");
printer->Print("hello\n");
const char* expected = "hellohello\n";
CHECK_EQUAL(expected, mockPrinter->getOutput());
}
TEST(Printer, PrintLong)
{
printer->Print(1234);
const char* expected = "1234";
CHECK_EQUAL(expected, mockPrinter->getOutput());
}
TEST(Printer, StreamOperators)
{
*printer << "n=" << 1234;
const char* expected = "n=1234";
CHECK_EQUAL(expected, mockPrinter->getOutput());
}
| null |
12 | cpp | cpputest | EventDispatcherTest.cpp | examples/AllTests/EventDispatcherTest.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#if CPPUTEST_USE_NEW_MACROS
#undef realloc
#undef new
#endif
#include "EventDispatcher.h"
#if CPPUTEST_USE_NEW_MACROS
#include "CppUTest/MemoryLeakDetectorNewMacros.h"
#endif
#include "CppUTest/TestHarness.h"
#include "CppUTestExt/MockSupport.h"
class ObserverMock : public EventObserver
{
public:
virtual void notify(const Event& event, int timeOutInSeconds) CPPUTEST_OVERRIDE
{
mock()
.actualCall("notify")
.onObject(this)
.withParameterOfType("Event", "event", (void*)&event)
.withParameter("timeOutInSeconds", timeOutInSeconds);
}
virtual void notifyRegistration(EventObserver* newObserver) CPPUTEST_OVERRIDE
{
mock().actualCall("notifyRegistration").onObject(this).withParameter("newObserver", newObserver);
}
};
class EventComparator : public MockNamedValueComparator
{
public:
virtual bool isEqual(const void* object1, const void* object2) CPPUTEST_OVERRIDE
{
return ((const Event*)object1)->type == ((const Event*)object2)->type;
}
virtual SimpleString valueToString(const void* object) CPPUTEST_OVERRIDE
{
return StringFrom(((const Event*)object)->type);
}
};
TEST_GROUP(EventDispatcher)
{
Event event;
EventDispatcher* dispatcher;
ObserverMock observer;
ObserverMock observer2;
EventComparator eventComparator;
void setup() CPPUTEST_OVERRIDE
{
dispatcher = new EventDispatcher;
mock().installComparator("Event", eventComparator);
}
void teardown() CPPUTEST_OVERRIDE
{
delete dispatcher;
mock().removeAllComparatorsAndCopiers();
}
};
TEST(EventDispatcher, EventWithoutRegistrationsResultsIntoNoCalls)
{
dispatcher->dispatchEvent(event, 10);
}
TEST(EventDispatcher, EventWithRegistrationForEventResultsIntoCallback)
{
mock()
.expectOneCall("notify")
.onObject(&observer)
.withParameterOfType("Event", "event", &event)
.withParameter("timeOutInSeconds", 10);
event.type = IMPORTANT_EVENT;
dispatcher->registerObserver(IMPORTANT_EVENT, &observer);
dispatcher->dispatchEvent(event, 10);
}
TEST(EventDispatcher, DifferentEventWithRegistrationDoesNotResultIntoCallback)
{
event.type = LESS_IMPORTANT_EVENT;
dispatcher->registerObserver(IMPORTANT_EVENT, &observer);
dispatcher->dispatchEvent(event, 10);
}
TEST(EventDispatcher, RegisterTwoObserversResultIntoTwoCallsAndARegistrationNotification)
{
mock()
.expectOneCall("notify")
.onObject(&observer)
.withParameterOfType("Event", "event", &event)
.withParameter("timeOutInSeconds", 10);
mock()
.expectOneCall("notify")
.onObject(&observer2)
.withParameterOfType("Event", "event", &event)
.withParameter("timeOutInSeconds", 10);
mock().expectOneCall("notifyRegistration").onObject(&observer).withParameter("newObserver", &observer2);
event.type = IMPORTANT_EVENT;
dispatcher->registerObserver(IMPORTANT_EVENT, &observer);
dispatcher->registerObserver(IMPORTANT_EVENT, &observer2);
dispatcher->dispatchEvent(event, 10);
}
| null |
13 | cpp | cpputest | FEDemoTest.cpp | examples/AllTests/FEDemoTest.cpp | null | /*
* Copyright (c) 2016, Michael Feathers, James Grenning, Bas Vodde
* and Arnd Strube. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/CommandLineTestRunner.h"
#include "CppUTest/TestHarness.h"
#include "CppUTest/TestRegistry.h"
#if CPPUTEST_HAVE_FENV
#include "CppUTestExt/IEEE754ExceptionsPlugin.h"
/*
* To see a demonstration of tests failing as a result of IEEE754ExceptionsPlugin
* picking up floating point errors, run the test executable with the -ri option.
*
*/
extern "C" {
#include <fenv.h>
}
#include <limits>
TEST_GROUP(FE_Demo)
{
void setup() CPPUTEST_OVERRIDE
{
IEEE754ExceptionsPlugin::disableInexact();
}
};
IGNORE_TEST(FE_Demo, should_fail_when_FE_DIVBYZERO_is_set)
{
float f = 1.0f;
CHECK((f /= 0.0f) >= std::numeric_limits<float>::infinity());
}
IGNORE_TEST(FE_Demo, should_fail_when_FE_UNDERFLOW_is_set)
{
volatile float f = 0.01f;
while (f > 0.0f)
f = f * f;
CHECK(f == 0.0f);
}
IGNORE_TEST(FE_Demo, should_fail_when_FE_OVERFLOW_is_set)
{
volatile float f = 1000.0f;
while (f < std::numeric_limits<float>::infinity())
f = f * f;
CHECK(f >= std::numeric_limits<float>::infinity());
}
IGNORE_TEST(FE_Demo, should_fail_when_FE_INEXACT_is_set)
{
IEEE754ExceptionsPlugin::enableInexact();
float f = 10.0f;
DOUBLES_EQUAL((double)(f / 3.0f), (double)3.333f, (double)0.001f);
}
TEST(FE_Demo, should_succeed_when_no_flags_are_set)
{
CHECK(5.0f == 15.0f / 3.0f);
}
#endif
| null |
14 | cpp | cpputest | CircularBufferTest.cpp | examples/AllTests/CircularBufferTest.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/TestHarness.h"
#include "MockPrinter.h"
#include "CircularBuffer.h"
TEST_GROUP(CircularBuffer)
{
CircularBuffer* buffer;
void setup() CPPUTEST_OVERRIDE
{
buffer = new CircularBuffer();
}
void teardown() CPPUTEST_OVERRIDE
{
delete buffer;
}
void fillTheQueue(int seed, int howMany)
{
for (int i = 0; i < howMany; i++)
buffer->Put(seed + i);
}
void removeFromQueue(int howMany)
{
for (int i = 0; i < howMany; i++)
buffer->Get();
}
};
TEST(CircularBuffer, EmptyAfterCreation)
{
CHECK(buffer->IsEmpty());
}
TEST(CircularBuffer, NotEmpty)
{
buffer->Put(10046);
CHECK(!buffer->IsEmpty());
}
TEST(CircularBuffer, NotEmptyThenEmpty)
{
buffer->Put(4567);
CHECK(!buffer->IsEmpty());
buffer->Get();
CHECK(buffer->IsEmpty());
}
TEST(CircularBuffer, GetPutOneValue)
{
buffer->Put(4567);
LONGS_EQUAL(4567, buffer->Get());
}
TEST(CircularBuffer, GetPutAFew)
{
buffer->Put(1);
buffer->Put(2);
buffer->Put(3);
LONGS_EQUAL(1, buffer->Get());
LONGS_EQUAL(2, buffer->Get());
LONGS_EQUAL(3, buffer->Get());
}
TEST(CircularBuffer, Capacity)
{
CircularBuffer b(2);
LONGS_EQUAL(2, b.Capacity());
}
TEST(CircularBuffer, IsFull)
{
fillTheQueue(0, buffer->Capacity());
CHECK(buffer->IsFull());
}
TEST(CircularBuffer, EmptyToFullToEmpty)
{
fillTheQueue(100, buffer->Capacity());
CHECK(buffer->IsFull());
removeFromQueue(buffer->Capacity());
CHECK(buffer->IsEmpty());
}
TEST(CircularBuffer, WrapAround)
{
fillTheQueue(100, buffer->Capacity());
CHECK(buffer->IsFull());
LONGS_EQUAL(100, buffer->Get());
CHECK(!buffer->IsFull());
buffer->Put(1000);
CHECK(buffer->IsFull());
removeFromQueue(buffer->Capacity() - 1);
LONGS_EQUAL(1000, buffer->Get());
CHECK(buffer->IsEmpty());
}
TEST(CircularBuffer, PutToFull)
{
int capacity = buffer->Capacity();
fillTheQueue(900, capacity);
buffer->Put(9999);
for (int i = 0; i < buffer->Capacity() - 1; i++)
LONGS_EQUAL(i + 900 + 1, buffer->Get());
LONGS_EQUAL(9999, buffer->Get());
CHECK(buffer->IsEmpty());
}
// Sometime people ask what tests the tests.
// Do you know the answer
TEST(CircularBuffer, GetFromEmpty)
{
LONGS_EQUAL(-1, buffer->Get());
CHECK(buffer->IsEmpty());
}
/*
* the next tests demonstrate using a mock object for
* capturing output
*
*/
TEST(CircularBuffer, PrintEmpty)
{
MockPrinter mock;
Printer* p = &mock;
buffer->Print(p);
STRCMP_EQUAL("Circular buffer content:\n<>\n", mock.getOutput().c_str());
}
TEST(CircularBuffer, PrintAfterOnePut)
{
MockPrinter mock;
buffer->Put(1);
buffer->Print(&mock);
STRCMP_EQUAL("Circular buffer content:\n<1>\n", mock.getOutput().c_str());
}
TEST(CircularBuffer, PrintNotYetWrappedOrFull)
{
MockPrinter mock;
buffer->Put(1);
buffer->Put(2);
buffer->Put(3);
buffer->Print(&mock);
STRCMP_EQUAL("Circular buffer content:\n<1, 2, 3>\n", mock.getOutput().c_str());
}
TEST(CircularBuffer, PrintNotYetWrappedAndIsFull)
{
MockPrinter mock;
fillTheQueue(200, buffer->Capacity());
buffer->Print(&mock);
const char* expected =
"Circular buffer content:\n"
"<200, 201, 202, 203, 204>\n";
STRCMP_EQUAL(expected, mock.getOutput().c_str());
}
TEST(CircularBuffer, PrintWrappedAndIsFullOldestToNewest)
{
MockPrinter mock;
fillTheQueue(200, buffer->Capacity());
buffer->Get();
buffer->Put(999);
buffer->Print(&mock);
const char* expected =
"Circular buffer content:\n"
"<201, 202, 203, 204, 999>\n";
STRCMP_EQUAL(expected, mock.getOutput().c_str());
}
TEST(CircularBuffer, PrintWrappedAndFullOverwriteOldest)
{
MockPrinter mock;
fillTheQueue(200, buffer->Capacity());
buffer->Put(9999);
buffer->Print(&mock);
const char* expected =
"Circular buffer content:\n"
"<201, 202, 203, 204, 9999>\n";
STRCMP_EQUAL(expected, mock.getOutput().c_str());
}
TEST(CircularBuffer, PrintBoundary)
{
MockPrinter mock;
fillTheQueue(200, buffer->Capacity());
removeFromQueue(buffer->Capacity() - 2);
buffer->Put(888);
fillTheQueue(300, buffer->Capacity() - 1);
buffer->Print(&mock);
const char* expected =
"Circular buffer content:\n"
"<888, 300, 301, 302, 303>\n";
STRCMP_EQUAL(expected, mock.getOutput().c_str());
}
TEST(CircularBuffer, FillEmptyThenPrint)
{
MockPrinter mock;
fillTheQueue(200, buffer->Capacity());
removeFromQueue(buffer->Capacity());
buffer->Print(&mock);
const char* expected =
"Circular buffer content:\n"
"<>\n";
STRCMP_EQUAL(expected, mock.getOutput().c_str());
}
| null |
15 | cpp | cpputest | MockPrinter.h | examples/AllTests/MockPrinter.h | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef D_MockPrinter_H
#define D_MockPrinter_H
///////////////////////////////////////////////////////////////////////////////
//
// MockPrinter.h
//
// MockPrinter is responsible for providing a test stub for Printer
//
///////////////////////////////////////////////////////////////////////////////
#include "Printer.h"
#include "CppUTest/SimpleString.h"
#include <stdlib.h>
#include <string>
class MockPrinter : public Printer
{
public:
explicit MockPrinter() {}
virtual ~MockPrinter() CPPUTEST_DESTRUCTOR_OVERRIDE {}
virtual void Print(const char* s) CPPUTEST_OVERRIDE
{
savedOutput.append(s);
}
virtual void Print(long int value) CPPUTEST_OVERRIDE
{
SimpleString buffer;
buffer = StringFromFormat("%ld", value);
savedOutput.append(buffer.asCharString());
}
std::string getOutput() const
{
return savedOutput;
}
private:
std::string savedOutput;
MockPrinter(const MockPrinter&);
MockPrinter& operator=(const MockPrinter&);
};
#endif // D_MockPrinter_H
| null |
16 | cpp | cpputest | MockDocumentationTest.cpp | examples/AllTests/MockDocumentationTest.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/TestHarness.h"
#include "CppUTestExt/MockSupport.h"
#include "CppUTestExt/MockSupport_c.h"
TEST_GROUP(FirstTestGroup)
{
};
TEST(FirstTestGroup, FirsTest)
{
// FAIL("Fail me!");
}
TEST(FirstTestGroup, SecondTest)
{
// STRCMP_EQUAL("hello", "world");
}
TEST_GROUP(MockDocumentation)
{
};
static void productionCode()
{
mock().actualCall("productionCode");
}
TEST(MockDocumentation, SimpleScenario)
{
mock().expectOneCall("productionCode");
productionCode();
mock().checkExpectations();
}
class ClassFromProductionCode
{
public:
virtual void importantFunction() {}
virtual ~ClassFromProductionCode() {}
};
class ClassFromProductionCodeMock : public ClassFromProductionCode
{
public:
virtual void importantFunction() CPPUTEST_OVERRIDE
{
mock().actualCall("importantFunction").onObject(this);
}
};
TEST(MockDocumentation, SimpleScenarioObject)
{
ClassFromProductionCode* object = new ClassFromProductionCodeMock; /* create mock instead of real thing */
mock().expectOneCall("importantFunction").onObject(object);
object->importantFunction();
mock().checkExpectations();
delete object;
}
static void parameters_function(int p1, const char* p2)
{
void* object = (void*)1;
mock().actualCall("function").onObject(object).withParameter("p1", p1).withParameter("p2", p2);
}
TEST(MockDocumentation, parameters)
{
void* object = (void*)1;
mock().expectOneCall("function").onObject(object).withParameter("p1", 2).withParameter("p2", "hah");
parameters_function(2, "hah");
}
class MyTypeComparator : public MockNamedValueComparator
{
public:
virtual bool isEqual(const void* object1, const void* object2) CPPUTEST_OVERRIDE
{
return object1 == object2;
}
virtual SimpleString valueToString(const void* object) CPPUTEST_OVERRIDE
{
return StringFrom(object);
}
};
TEST(MockDocumentation, ObjectParameters)
{
void* object = (void*)1;
MyTypeComparator comparator;
mock().installComparator("myType", comparator);
mock().expectOneCall("function").withParameterOfType("myType", "parameterName", object);
mock().clear();
mock().removeAllComparatorsAndCopiers();
}
TEST(MockDocumentation, returnValue)
{
mock().expectOneCall("function").andReturnValue(10);
mock().actualCall("function").returnValue().getIntValue();
int value = mock().returnValue().getIntValue();
LONGS_EQUAL(10, value);
}
TEST(MockDocumentation, setData)
{
ClassFromProductionCode object;
mock().setData("importantValue", 10);
mock().setDataObject("importantObject", "ClassFromProductionCode", &object);
ClassFromProductionCode* pobject;
int value = mock().getData("importantValue").getIntValue();
pobject = (ClassFromProductionCode*)mock().getData("importantObject").getObjectPointer();
LONGS_EQUAL(10, value);
POINTERS_EQUAL(pobject, &object);
}
static void doSomethingThatWouldOtherwiseBlowUpTheMockingFramework() {}
TEST(MockDocumentation, otherMockSupport)
{
mock().crashOnFailure();
// mock().actualCall("unex");
mock().expectOneCall("foo");
mock().ignoreOtherCalls();
mock().disable();
doSomethingThatWouldOtherwiseBlowUpTheMockingFramework();
mock().enable();
mock().clear();
}
TEST(MockDocumentation, scope)
{
mock("xmlparser").expectOneCall("open");
mock("filesystem").ignoreOtherCalls();
mock("xmlparser").actualCall("open");
}
static int equalMethod(const void* object1, const void* object2)
{
return object1 == object2;
}
static const char* toStringMethod(const void*)
{
return "string";
}
TEST(MockDocumentation, CInterface)
{
void* object = (void*)0x1;
mock_c()->expectOneCall("foo")->withIntParameters("integer", 10)->andReturnDoubleValue(1.11);
double d = mock_c()->actualCall("foo")->withIntParameters("integer", 10)->returnValue().value.doubleValue;
DOUBLES_EQUAL(1.11, d, 0.00001);
mock_c()->installComparator("type", equalMethod, toStringMethod);
mock_scope_c("scope")->expectOneCall("bar")->withParameterOfType("type", "name", object);
mock_scope_c("scope")->actualCall("bar")->withParameterOfType("type", "name", object);
mock_c()->removeAllComparatorsAndCopiers();
mock_c()->setIntData("important", 10);
mock_c()->checkExpectations();
mock_c()->clear();
}
TEST_GROUP(FooTestGroup)
{
void setup() CPPUTEST_OVERRIDE
{
// Init stuff
}
void teardown() CPPUTEST_OVERRIDE
{
// Uninit stuff
}
};
TEST(FooTestGroup, Foo)
{
// Test FOO
}
TEST(FooTestGroup, MoreFoo)
{
// Test more FOO
}
TEST_GROUP(BarTestGroup)
{
void setup() CPPUTEST_OVERRIDE
{
// Init Bar
}
};
TEST(BarTestGroup, Bar)
{
// Test Bar
}
| null |
17 | cpp | cpputest | HelloTest.cpp | examples/AllTests/HelloTest.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "hello.h"
#include <stdio.h>
#include <stdarg.h>
#include "CppUTest/TestHarness.h"
static SimpleString* buffer;
TEST_GROUP(HelloWorld)
{
static int output_method(const char* output, ...)
{
va_list arguments;
va_start(arguments, output);
*buffer = VStringFromFormat(output, arguments);
va_end(arguments);
return 1;
}
void setup() CPPUTEST_OVERRIDE
{
buffer = new SimpleString();
UT_PTR_SET(PrintFormated, &output_method);
}
void teardown() CPPUTEST_OVERRIDE
{
delete buffer;
}
};
TEST(HelloWorld, PrintOk)
{
printHelloWorld();
STRCMP_EQUAL("Hello World!\n", buffer->asCharString());
}
| null |
18 | cpp | cpputest | AllTests.cpp | examples/AllTests/AllTests.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/CommandLineTestRunner.h"
#include "CppUTest/TestPlugin.h"
#include "CppUTest/TestRegistry.h"
#include "CppUTestExt/IEEE754ExceptionsPlugin.h"
#include "CppUTestExt/MockSupportPlugin.h"
class MyDummyComparator : public MockNamedValueComparator
{
public:
virtual bool isEqual(const void* object1, const void* object2) CPPUTEST_OVERRIDE
{
return object1 == object2;
}
virtual SimpleString valueToString(const void* object) CPPUTEST_OVERRIDE
{
return StringFrom(object);
}
};
int main(int ac, char** av)
{
MyDummyComparator dummyComparator;
MockSupportPlugin mockPlugin;
IEEE754ExceptionsPlugin ieee754Plugin;
mockPlugin.installComparator("MyDummyType", dummyComparator);
TestRegistry::getCurrentRegistry()->installPlugin(&mockPlugin);
TestRegistry::getCurrentRegistry()->installPlugin(&ieee754Plugin);
return CommandLineTestRunner::RunAllTests(ac, av);
}
#include "AllTests.h"
| null |
19 | cpp | cpputest | AllTests.h | examples/AllTests/AllTests.h | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
IMPORT_TEST_GROUP(Printer);
IMPORT_TEST_GROUP(CircularBuffer);
IMPORT_TEST_GROUP(HelloWorld);
IMPORT_TEST_GROUP(EventDispatcher);
IMPORT_TEST_GROUP(MockDocumentation);
| null |
20 | cpp | cpputest | UtestPlatform.cpp | src/Platforms/C2000/UtestPlatform.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* Un-comment to use buffer instead of std out */
// #define USE_BUFFER_OUTPUT 1
#include <cstdlib>
#include "CppUTest/TestHarness.h"
#undef malloc
#undef free
#undef calloc
#undef realloc
#undef strdup
#undef strndup
#define far // eliminate "meaningless type qualifier" warning
extern "C" {
#include <time.h>
#include <stdio.h>
#include <stdarg.h>
#include <setjmp.h>
#include <string.h>
#include <math.h>
#include <ctype.h>
}
#undef far
#include "CppUTest/PlatformSpecificFunctions.h"
static jmp_buf test_exit_jmp_buf[10];
static int jmp_buf_index = 0;
#if USE_BUFFER_OUTPUT
// Buffer for crude output routine
#define BUFFER_SIZE 4096
static char buffer [BUFFER_SIZE]; /* "never used" warning is OK */
static int idx = 0;
#endif
TestOutput::WorkingEnvironment PlatformSpecificGetWorkingEnvironment()
{
return TestOutput::eclipse;
}
static void C2000RunTestInASeperateProcess(UtestShell* shell, TestPlugin* plugin, TestResult* result)
{
result->addFailure(TestFailure(shell, "-p doesn't work on this platform, as it is lacking fork.\b"));
}
void (*PlatformSpecificRunTestInASeperateProcess)(UtestShell*, TestPlugin*, TestResult*) =
C2000RunTestInASeperateProcess;
extern "C" {
static int C2000SetJmp(void (*function) (void* data), void* data)
{
if (0 == setjmp(test_exit_jmp_buf[jmp_buf_index])) {
jmp_buf_index++;
function(data);
jmp_buf_index--;
return 1;
}
return 0;
}
static void C2000LongJmp()
{
jmp_buf_index--;
longjmp(test_exit_jmp_buf[jmp_buf_index], 1);
}
static void C2000RestoreJumpBuffer()
{
jmp_buf_index--;
}
int (*PlatformSpecificSetJmp)(void (*function) (void*), void*) = C2000SetJmp;
void (*PlatformSpecificLongJmp)(void) = C2000LongJmp;
void (*PlatformSpecificRestoreJumpBuffer)(void) = C2000RestoreJumpBuffer;
static unsigned long C2000TimeInMillis()
{
/* The TI c2000 platform does not have Posix support and thus lacks struct timespec.
* Also, clock() always returns 0 in the simulator. Hence we work with struct tm.tm_hour
* This has two consequences:
* (1) We need to sum up the part in order to get an "elapsed since" time value,
* rather than just using tm_sec.
* (2) There is a possibility of overflow, since we stop at the hour
* (3) Resolution is 1 s, even though we return ms.
*/
time_t t = time((time_t*)0);
struct tm * ptm = gmtime(&t);
unsigned long result = (unsigned long)
((ptm->tm_sec + ptm->tm_min * (time_t)60 + ptm->tm_hour * (time_t)3600) * (time_t)1000);
return result;
}
static const char* TimeStringImplementation()
{
time_t tm = time(NULL);
return ctime(&tm);
}
unsigned long (*GetPlatformSpecificTimeInMillis)() = C2000TimeInMillis;
const char* (*GetPlatformSpecificTimeString)() = TimeStringImplementation;
extern int vsnprintf(char*, size_t, const char*, va_list); // not std::vsnprintf()
extern int (*PlatformSpecificVSNprintf)(char *, size_t, const char*, va_list) = vsnprintf;
PlatformSpecificFile C2000FOpen(const char* filename, const char* flag)
{
return fopen(filename, flag);
}
static void C2000FPuts(const char* str, PlatformSpecificFile file)
{
#if USE_BUFFER_OUTPUT
if (file == PlatformSpecificStdOut) {
while (*str && (idx < BUFFER_SIZE)) {
buf[idx++] = *str++;
}
}
else
#endif
{
fputs(str, (FILE*)file);
}
}
static void C2000FClose(PlatformSpecificFile file)
{
fclose((FILE*)file);
}
PlatformSpecificFile PlatformSpecificStdOut = stdout;
PlatformSpecificFile (*PlatformSpecificFOpen)(const char* filename, const char* flag) = C2000FOpen;
void (*PlatformSpecificFPuts)(const char* str, PlatformSpecificFile file) = C2000FPuts;
void (*PlatformSpecificFClose)(PlatformSpecificFile file) = C2000FClose;
static void CL2000Flush()
{
fflush(stdout);
}
extern void (*PlatformSpecificFlush)(void) = CL2000Flush;
static void* C2000Malloc(size_t size)
{
return (void*)malloc((unsigned long)size);
}
static void* C2000Realloc (void* memory, size_t size)
{
return (void*)realloc(memory, (unsigned long)size);
}
static void C2000Free(void* memory)
{
free(memory);
}
static void* C2000MemCpy(void* s1, const void* s2, size_t size)
{
return (void*)memcpy(s1, s2, size);
}
static void* C2000Memset(void* mem, int c, size_t size)
{
register unsigned long i = size;
register long p = (long) mem;
while (i--) *__farptr_to_word(p++) = c;
return mem;
}
void* (*PlatformSpecificMalloc)(size_t size) = C2000Malloc;
void* (*PlatformSpecificRealloc)(void* memory, size_t size) = C2000Realloc;
void (*PlatformSpecificFree)(void* memory) = C2000Free;
void* (*PlatformSpecificMemCpy)(void* s1, const void* s2, size_t size) = C2000MemCpy;
void* (*PlatformSpecificMemset)(void* mem, int c, size_t size) = C2000Memset;
/*
double PlatformSpecificFabs(double d)
{
return fabs(d);
}
*/
double (*PlatformSpecificFabs)(double) = fabs;
static int IsNanImplementation(double d)
{
return 0;
}
static int IsInfImplementation(double d)
{
return 0;
}
int (*PlatformSpecificIsNan)(double d) = IsNanImplementation;
int (*PlatformSpecificIsInf)(double d) = IsInfImplementation;
static PlatformSpecificMutex DummyMutexCreate(void)
{
return 0;
}
static void DummyMutexLock(PlatformSpecificMutex mtx)
{
}
static void DummyMutexUnlock(PlatformSpecificMutex mtx)
{
}
static void DummyMutexDestroy(PlatformSpecificMutex mtx)
{
}
PlatformSpecificMutex (*PlatformSpecificMutexCreate)(void) = DummyMutexCreate;
void (*PlatformSpecificSrand)(unsigned int) = srand;
int (*PlatformSpecificRand)(void) = rand;
void (*PlatformSpecificMutexLock)(PlatformSpecificMutex) = DummyMutexLock;
void (*PlatformSpecificMutexUnlock)(PlatformSpecificMutex) = DummyMutexUnlock;
void (*PlatformSpecificMutexDestroy)(PlatformSpecificMutex) = DummyMutexDestroy;
void (*PlatformSpecificAbort)(void) = abort;
}
| null |
21 | cpp | cpputest | UtestPlatform.cpp | src/Platforms/GccNoStdC/UtestPlatform.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/TestHarness.h"
#undef malloc
#undef free
#undef calloc
#undef realloc
#undef strdup
#undef strndup
#include "CppUTest/PlatformSpecificFunctions.h"
void (*PlatformSpecificRunTestInASeperateProcess)(UtestShell*, TestPlugin*, TestResult*) = NULLPTR;
int (*PlatformSpecificFork)() = NULLPTR;
int (*PlatformSpecificWaitPid)(int, int*, int) = NULLPTR;
TestOutput::WorkingEnvironment PlatformSpecificGetWorkingEnvironment()
{
return TestOutput::eclipse;
}
void (*PlatformSpecificLongJmp)() = NULLPTR;
int (*PlatformSpecificSetJmp)(void (*)(void*), void*) = NULLPTR;
void (*PlatformSpecificRestoreJumpBuffer)() = NULLPTR;
unsigned long (*GetPlatformSpecificTimeInMillis)() = NULLPTR;
const char* (*GetPlatformSpecificTimeString)() = NULLPTR;
/* IO operations */
PlatformSpecificFile PlatformSpecificStdOut = NULLPTR;
PlatformSpecificFile (*PlatformSpecificFOpen)(const char* filename, const char* flag) = NULLPTR;
void (*PlatformSpecificFPuts)(const char* str, PlatformSpecificFile file) = NULLPTR;
void (*PlatformSpecificFClose)(PlatformSpecificFile file) = NULLPTR;
void (*PlatformSpecificFlush)(void) = NULLPTR;
int (*PlatformSpecificVSNprintf)(char *str, size_t size, const char* format, va_list va_args_list) = NULLPTR;
/* Dynamic Memory operations */
void* (*PlatformSpecificMalloc)(size_t) = NULLPTR;
void* (*PlatformSpecificRealloc)(void*, size_t) = NULLPTR;
void (*PlatformSpecificFree)(void*) = NULLPTR;
void* (*PlatformSpecificMemCpy)(void*, const void*, size_t) = NULLPTR;
void* (*PlatformSpecificMemset)(void*, int, size_t) = NULLPTR;
double (*PlatformSpecificFabs)(double) = NULLPTR;
int (*PlatformSpecificIsNan)(double) = NULLPTR;
int (*PlatformSpecificIsInf)(double) = NULLPTR;
int (*PlatformSpecificAtExit)(void(*func)(void)) = NULLPTR;
PlatformSpecificMutex (*PlatformSpecificMutexCreate)(void) = NULLPTR;
void (*PlatformSpecificMutexLock)(PlatformSpecificMutex mtx) = NULLPTR;
void (*PlatformSpecificMutexUnlock)(PlatformSpecificMutex mtx) = NULLPTR;
void (*PlatformSpecificMutexDestroy)(PlatformSpecificMutex mtx) = NULLPTR;
void (*PlatformSpecificSrand)(unsigned int) = NULLPTR;
int (*PlatformSpecificRand)(void) = NULLPTR;
void (*PlatformSpecificAbort)(void) = NULLPTR;
| null |
22 | cpp | cpputest | UtestPlatform.cpp | src/Platforms/VisualCpp/UtestPlatform.cpp | null | #include <stdlib.h>
#include "CppUTest/TestHarness.h"
#undef malloc
#undef free
#undef calloc
#undef realloc
#undef strdup
#undef strndup
#include <stdio.h>
#include <stdarg.h>
#include <setjmp.h>
#include <string.h>
#include <math.h>
#include <float.h>
#include <time.h>
#include "CppUTest/PlatformSpecificFunctions.h"
#include <Windows.h>
#include <mmsystem.h>
#include <setjmp.h>
#ifdef STDC_WANT_SECURE_LIB
#define MAYBE_SECURE_FOPEN(fp, filename, flag) fopen_s((fp), (filename), (flag))
#define MAYBE_SECURE_VSNPRINTF(str, size, trunc, format, args) _vsnprintf_s((str), (size), (trunc), (format), (args))
#define MAYBE_SECURE_LOCALTIME(_tm, timer) localtime_s((_tm), (timer))
#else
#define MAYBE_SECURE_FOPEN(fp, filename, flag) *(fp) = fopen((filename), (flag))
#define MAYBE_SECURE_VSNPRINTF(str, size, trunc, format, args) _vsnprintf((str), (size), (format), (args))
#define MAYBE_SECURE_LOCALTIME(_tm, timer) memcpy(_tm, localtime(timer), sizeof(tm));
#endif
static jmp_buf test_exit_jmp_buf[10];
static int jmp_buf_index = 0;
static int VisualCppSetJmp(void (*function) (void* data), void* data)
{
if (0 == setjmp(test_exit_jmp_buf[jmp_buf_index])) {
jmp_buf_index++;
function(data);
jmp_buf_index--;
return 1;
}
return 0;
}
CPPUTEST_NORETURN static void VisualCppLongJmp()
{
jmp_buf_index--;
longjmp(test_exit_jmp_buf[jmp_buf_index], 1);
}
static void VisualCppRestoreJumpBuffer()
{
jmp_buf_index--;
}
int (*PlatformSpecificSetJmp)(void (*function) (void*), void* data) = VisualCppSetJmp;
void (*PlatformSpecificLongJmp)(void) = VisualCppLongJmp;
void (*PlatformSpecificRestoreJumpBuffer)(void) = VisualCppRestoreJumpBuffer;
static void VisualCppRunTestInASeperateProcess(UtestShell* shell, TestPlugin* /* plugin */, TestResult* result)
{
result->addFailure(TestFailure(shell, "-p doesn't work on this platform, as it is lacking fork.\b"));
}
void (*PlatformSpecificRunTestInASeperateProcess)(UtestShell* shell, TestPlugin* plugin, TestResult* result) =
VisualCppRunTestInASeperateProcess;
TestOutput::WorkingEnvironment PlatformSpecificGetWorkingEnvironment()
{
return TestOutput::visualStudio;
}
///////////// Time in millis
static unsigned long VisualCppTimeInMillis()
{
static LARGE_INTEGER s_frequency;
static const BOOL s_use_qpc = QueryPerformanceFrequency(&s_frequency);
if (s_use_qpc)
{
LARGE_INTEGER now;
QueryPerformanceCounter(&now);
return (unsigned long)((now.QuadPart * 1000) / s_frequency.QuadPart);
}
else
{
#ifdef TIMERR_NOERROR
return (unsigned long)timeGetTime();
#else
#if !defined(_WIN32_WINNT) || !defined(_WIN32_WINNT_VISTA) || (_WIN32_WINNT < _WIN32_WINNT_VISTA)
return (unsigned long)GetTickCount();
#else
return (unsigned long)GetTickCount64();
#endif
#endif
}
}
unsigned long (*GetPlatformSpecificTimeInMillis)() = VisualCppTimeInMillis;
///////////// Time in String
static const char* VisualCppTimeString()
{
time_t the_time = time(NULLPTR);
struct tm the_local_time;
static char dateTime[80];
MAYBE_SECURE_LOCALTIME(&the_local_time, &the_time);
strftime(dateTime, 80, "%Y-%m-%dT%H:%M:%S", &the_local_time);
return dateTime;
}
const char* (*GetPlatformSpecificTimeString)() = VisualCppTimeString;
////// taken from gcc
static int VisualCppVSNprintf(char *str, size_t size, const char* format, va_list args)
{
char* buf = NULLPTR;
size_t sizeGuess = size;
int result = MAYBE_SECURE_VSNPRINTF( str, size, _TRUNCATE, format, args);
str[size-1] = 0;
while (result == -1)
{
if (buf)
free(buf);
sizeGuess += 10;
buf = (char*)malloc(sizeGuess);
result = MAYBE_SECURE_VSNPRINTF( buf, sizeGuess, _TRUNCATE, format, args);
}
if (buf)
free(buf);
return result;
}
int (*PlatformSpecificVSNprintf)(char *str, size_t size, const char* format, va_list va_args_list) = VisualCppVSNprintf;
static PlatformSpecificFile VisualCppFOpen(const char* filename, const char* flag)
{
FILE* file;
MAYBE_SECURE_FOPEN(&file, filename, flag);
return file;
}
static void VisualCppFPuts(const char* str, PlatformSpecificFile file)
{
fputs(str, (FILE*)file);
}
static void VisualCppFClose(PlatformSpecificFile file)
{
fclose((FILE*)file);
}
PlatformSpecificFile PlatformSpecificStdOut = stdout;
PlatformSpecificFile (*PlatformSpecificFOpen)(const char* filename, const char* flag) = VisualCppFOpen;
void (*PlatformSpecificFPuts)(const char* str, PlatformSpecificFile file) = VisualCppFPuts;
void (*PlatformSpecificFClose)(PlatformSpecificFile file) = VisualCppFClose;
static void VisualCppFlush()
{
fflush(stdout);
}
void (*PlatformSpecificFlush)(void) = VisualCppFlush;
static void* VisualCppMalloc(size_t size)
{
return malloc(size);
}
static void* VisualCppReAlloc(void* memory, size_t size)
{
return realloc(memory, size);
}
static void VisualCppFree(void* memory)
{
free(memory);
}
void (*PlatformSpecificSrand)(unsigned int) = srand;
int (*PlatformSpecificRand)(void) = rand;
void* (*PlatformSpecificMalloc)(size_t size) = VisualCppMalloc;
void* (*PlatformSpecificRealloc)(void* memory, size_t size) = VisualCppReAlloc;
void (*PlatformSpecificFree)(void* memory) = VisualCppFree;
void* (*PlatformSpecificMemCpy)(void* s1, const void* s2, size_t size) = memcpy;
void* (*PlatformSpecificMemset)(void* mem, int c, size_t size) = memset;
static int IsInfImplementation(double d)
{
return !_finite(d);
}
double (*PlatformSpecificFabs)(double d) = fabs;
extern "C" int (*PlatformSpecificIsNan)(double) = _isnan;
extern "C" int (*PlatformSpecificIsInf)(double) = IsInfImplementation;
int (*PlatformSpecificAtExit)(void(*func)(void)) = atexit;
static PlatformSpecificMutex VisualCppMutexCreate(void)
{
CRITICAL_SECTION *critical_section = new CRITICAL_SECTION;
InitializeCriticalSection(critical_section);
return (PlatformSpecificMutex)critical_section;
}
static void VisualCppMutexLock(PlatformSpecificMutex mutex)
{
EnterCriticalSection((CRITICAL_SECTION*)mutex);
}
static void VisualCppMutexUnlock(PlatformSpecificMutex mutex)
{
LeaveCriticalSection((CRITICAL_SECTION*)mutex);
}
static void VisualCppMutexDestroy(PlatformSpecificMutex mutex)
{
CRITICAL_SECTION *critical_section = (CRITICAL_SECTION*)mutex;
DeleteCriticalSection(critical_section);
delete critical_section;
}
PlatformSpecificMutex (*PlatformSpecificMutexCreate)(void) = VisualCppMutexCreate;
void (*PlatformSpecificMutexLock)(PlatformSpecificMutex) = VisualCppMutexLock;
void (*PlatformSpecificMutexUnlock)(PlatformSpecificMutex) = VisualCppMutexUnlock;
void (*PlatformSpecificMutexDestroy)(PlatformSpecificMutex) = VisualCppMutexDestroy;
void (*PlatformSpecificAbort)(void) = abort;
| null |
23 | cpp | cpputest | SymbianMemoryLeakWarning.cpp | src/Platforms/Symbian/SymbianMemoryLeakWarning.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning, Bas Vodde and Timo Puronen
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "MemoryLeakWarning.h"
#include <e32base.h>
MemoryLeakWarning* MemoryLeakWarning::_latest = NULL;
// naming convention due to CppUTest generic class name
class MemoryLeakWarningData : public CBase {
public:
TInt iInitialAllocCells;
TInt iExpectedLeaks;
TInt iInitialThreadHandleCount;
TInt iInitialProcessHandleCount;
};
MemoryLeakWarning::MemoryLeakWarning()
{
_latest = this;
CreateData();
}
MemoryLeakWarning::~MemoryLeakWarning()
{
DestroyData();
}
void MemoryLeakWarning::Enable()
{
}
const char* MemoryLeakWarning::FinalReport(int toBeDeletedLeaks)
{
TInt cellDifference(User::CountAllocCells() - _impl->iInitialAllocCells);
if( cellDifference != toBeDeletedLeaks ) {
return "Heap imbalance after test\n";
}
TInt processHandles;
TInt threadHandles;
RThread().HandleCount(processHandles, threadHandles);
if(_impl->iInitialProcessHandleCount != processHandles ||
_impl->iInitialThreadHandleCount != threadHandles) {
return "Handle count imbalance after test\n";
}
return "";
}
void MemoryLeakWarning::CheckPointUsage()
{
_impl->iInitialAllocCells = User::CountAllocCells();
RThread().HandleCount(_impl->iInitialProcessHandleCount, _impl->iInitialThreadHandleCount);
}
bool MemoryLeakWarning::UsageIsNotBalanced()
{
TInt allocatedCells(User::CountAllocCells());
if(_impl->iExpectedLeaks != 0) {
TInt difference(Abs(_impl->iInitialAllocCells - allocatedCells));
return difference != _impl->iExpectedLeaks;
}
return allocatedCells != _impl->iInitialAllocCells;
}
const char* MemoryLeakWarning::Message()
{
return "";
}
void MemoryLeakWarning::ExpectLeaks(int n)
{
_impl->iExpectedLeaks = n;
}
// this method leaves (no naming convention followed due to CppUTest framework
void MemoryLeakWarning::CreateData()
{
_impl = new(ELeave) MemoryLeakWarningData();
}
void MemoryLeakWarning::DestroyData()
{
delete _impl;
_impl = NULL;
}
MemoryLeakWarning* MemoryLeakWarning::GetLatest()
{
return _latest;
}
void MemoryLeakWarning::SetLatest(MemoryLeakWarning* latest)
{
_latest = latest;
}
| null |
24 | cpp | cpputest | UtestPlatform.cpp | src/Platforms/Symbian/UtestPlatform.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning, Bas Vodde and Timo Puronen
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/TestHarness.h"
#include <e32def.h>
#include <e32std.h>
#include <sys/time.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include "CppUTest/PlatformSpecificFunctions.h"
static jmp_buf test_exit_jmp_buf[10];
static int jmp_buf_index = 0;
int PlatformSpecificSetJmp(void (*function) (void* data), void* data)
{
if (0 == setjmp(test_exit_jmp_buf[jmp_buf_index])) {
jmp_buf_index++;
function(data);
jmp_buf_index--;
return 1;
}
return 0;
}
void PlatformSpecificLongJmp()
{
jmp_buf_index--;
longjmp(test_exit_jmp_buf[jmp_buf_index], 1);
}
void PlatformSpecificRestoreJumpBuffer()
{
jmp_buf_index--;
}
void PlatformSpecificRunTestInASeperateProcess(UtestShell* shell, TestPlugin* plugin, TestResult* result)
{
printf("-p doesn't work on this platform as it is not implemented. Running inside the process\b");
shell->runOneTest(plugin, *result);
}
static unsigned long TimeInMillisImplementation() {
struct timeval tv;
struct timezone tz;
::gettimeofday(&tv, &tz);
return ((unsigned long)tv.tv_sec * 1000) + ((unsigned long)tv.tv_usec / 1000);
}
unsigned long (*GetPlatformSpecificTimeInMillis)() = TimeInMillisImplementation;
TestOutput::WorkingEnvironment PlatformSpecificGetWorkingEnvironment()
{
return TestOutput::eclipse;
}
static SimpleString TimeStringImplementation() {
time_t tm = time(NULL);
return ctime(&tm);
}
SimpleString GetPlatformSpecificTimeString() = TimeStringImplementation;
int PlatformSpecificVSNprintf(char* str, size_t size, const char* format, va_list args) {
return vsnprintf(str, size, format, args);
}
void PlatformSpecificFlush() {
fflush(stdout);
}
double PlatformSpecificFabs(double d) {
return fabs(d);
}
void* PlatformSpecificMalloc(size_t size) {
return malloc(size);
}
void* PlatformSpecificRealloc (void* memory, size_t size) {
return realloc(memory, size);
}
void PlatformSpecificFree(void* memory) {
free(memory);
}
void* PlatformSpecificMemCpy(void* s1, const void* s2, size_t size) {
return memcpy(s1, s2, size);
}
void* PlatformSpecificMemset(void* mem, int c, size_t size)
{
return memset(mem, c, size);
}
PlatformSpecificFile PlatformSpecificStdOut = stdout;
PlatformSpecificFile PlatformSpecificFOpen(const char* filename, const char* flag) {
return fopen(filename, flag);
}
void PlatformSpecificFPuts(const char* str, PlatformSpecificFile file) {
fputs(str, (FILE*)file);
}
void PlatformSpecificFClose(PlatformSpecificFile file) {
fclose((FILE*)file);
}
extern "C" {
static int IsNanImplementation(double d)
{
return isnan(d);
}
static int IsInfImplementation(double d)
{
return isinf(d);
}
int (*PlatformSpecificIsNan)(double) = IsNanImplementation;
int (*PlatformSpecificIsInf)(double) = IsInfImplementation;
}
static PlatformSpecificMutex DummyMutexCreate(void)
{
FAIL("PlatformSpecificMutexCreate is not implemented");
return 0;
}
static void DummyMutexLock(PlatformSpecificMutex mtx)
{
FAIL("PlatformSpecificMutexLock is not implemented");
}
static void DummyMutexUnlock(PlatformSpecificMutex mtx)
{
FAIL("PlatformSpecificMutexUnlock is not implemented");
}
static void DummyMutexDestroy(PlatformSpecificMutex mtx)
{
FAIL("PlatformSpecificMutexDestroy is not implemented");
}
PlatformSpecificMutex (*PlatformSpecificMutexCreate)(void) = DummyMutexCreate;
void (*PlatformSpecificMutexLock)(PlatformSpecificMutex) = DummyMutexLock;
void (*PlatformSpecificMutexUnlock)(PlatformSpecificMutex) = DummyMutexUnlock;
void (*PlatformSpecificMutexDestroy)(PlatformSpecificMutex) = DummyMutexDestroy;
void (*PlatformSpecificAbort)(void) = abort;
| null |
25 | cpp | cpputest | UtestPlatform.cpp | src/Platforms/Dos/UtestPlatform.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* Un-comment to use buffer instead of std out */
// #define USE_BUFFER_OUTPUT 1
#include <cstdlib>
#include "CppUTest/TestHarness.h"
#undef malloc
#undef free
#undef calloc
#undef realloc
#undef strdup
#undef strndup
#define far // eliminate "meaningless type qualifier" warning
#include <time.h>
#include <stdio.h>
#include <stdarg.h>
#include <setjmp.h>
#include <string.h>
#include <math.h>
#include <ctype.h>
#undef far
#include "CppUTest/PlatformSpecificFunctions.h"
static jmp_buf test_exit_jmp_buf[10];
static int jmp_buf_index = 0;
TestOutput::WorkingEnvironment PlatformSpecificGetWorkingEnvironment()
{
return TestOutput::eclipse;
}
static void DummyRunTestInASeperateProcess(UtestShell* shell, TestPlugin* plugin, TestResult* result)
{
result->addFailure(TestFailure(shell, "-p doesn't work on this platform, as it is lacking fork.\b"));
}
static int DummyPlatformSpecificFork(void)
{
return 0;
}
static int DummyPlatformSpecificWaitPid(int, int*, int)
{
return 0;
}
void (*PlatformSpecificRunTestInASeperateProcess)(UtestShell*, TestPlugin*, TestResult*) = DummyRunTestInASeperateProcess;
int (*PlatformSpecificFork)() = DummyPlatformSpecificFork;
int (*PlatformSpecificWaitPid)(int, int*, int) = DummyPlatformSpecificWaitPid;
extern "C" {
static int DosSetJmp(void (*function) (void* data), void* data)
{
if (0 == setjmp(test_exit_jmp_buf[jmp_buf_index])) {
jmp_buf_index++;
function(data);
jmp_buf_index--;
return 1;
}
return 0;
}
static void DosLongJmp()
{
jmp_buf_index--;
longjmp(test_exit_jmp_buf[jmp_buf_index], 1);
}
static void DosRestoreJumpBuffer()
{
jmp_buf_index--;
}
int (*PlatformSpecificSetJmp)(void (*function) (void*), void*) = DosSetJmp;
void (*PlatformSpecificLongJmp)(void) = DosLongJmp;
void (*PlatformSpecificRestoreJumpBuffer)(void) = DosRestoreJumpBuffer;
static unsigned long DosTimeInMillis()
{
return (unsigned long)(clock() * 1000 / CLOCKS_PER_SEC);
}
static const char* DosTimeString()
{
time_t tm = time(NULL);
return ctime(&tm);
}
static int DosVSNprintf(char* str, size_t size, const char* format, va_list args) {
return vsnprintf(str, size, format, args);
}
unsigned long (*GetPlatformSpecificTimeInMillis)() = DosTimeInMillis;
const char* (*GetPlatformSpecificTimeString)() = DosTimeString;
int (*PlatformSpecificVSNprintf)(char *, size_t, const char*, va_list) = DosVSNprintf;
PlatformSpecificFile DosFOpen(const char* filename, const char* flag)
{
return fopen(filename, flag);
}
static void DosFPuts(const char* str, PlatformSpecificFile file)
{
fputs(str, (FILE*)file);
}
static void DosFClose(PlatformSpecificFile file)
{
fclose((FILE*)file);
}
PlatformSpecificFile PlatformSpecificStdOut = stdout;
PlatformSpecificFile (*PlatformSpecificFOpen)(const char* filename, const char* flag) = DosFOpen;
void (*PlatformSpecificFPuts)(const char* str, PlatformSpecificFile file) = DosFPuts;
void (*PlatformSpecificFClose)(PlatformSpecificFile file) = DosFClose;
static void DosFlush()
{
fflush(stdout);
}
extern void (*PlatformSpecificFlush)(void) = DosFlush;
static void* DosMalloc(size_t size)
{
return malloc(size);
}
static void* DosRealloc (void* memory, size_t size)
{
return realloc(memory, size);
}
static void DosFree(void* memory)
{
free(memory);
}
static void* DosMemCpy(void* s1, const void* s2, size_t size)
{
return memcpy(s1, s2, size);
}
static void* DosMemset(void* mem, int c, size_t size)
{
return memset(mem, c, size);
}
void* (*PlatformSpecificMalloc)(size_t size) = DosMalloc;
void* (*PlatformSpecificRealloc)(void* memory, size_t size) = DosRealloc;
void (*PlatformSpecificFree)(void* memory) = DosFree;
void* (*PlatformSpecificMemCpy)(void* s1, const void* s2, size_t size) = DosMemCpy;
void* (*PlatformSpecificMemset)(void* mem, int c, size_t size) = DosMemset;
static void DosSrand(unsigned int seed)
{
srand(seed);
}
static int DosRand()
{
return rand();
}
static double DosFabs(double d)
{
return fabs(d);
}
static int DosIsNan(double d)
{
return isnan(d);
}
static int DosIsInf(double d)
{
return isinf(d);
}
void (*PlatformSpecificSrand)(unsigned int) = DosSrand;
int (*PlatformSpecificRand)(void) = DosRand;
double (*PlatformSpecificFabs)(double) = DosFabs;
int (*PlatformSpecificIsNan)(double d) = DosIsNan;
int (*PlatformSpecificIsInf)(double d) = DosIsInf;
static PlatformSpecificMutex DummyMutexCreate(void)
{
return 0;
}
static void DummyMutexLock(PlatformSpecificMutex mtx)
{
}
static void DummyMutexUnlock(PlatformSpecificMutex mtx)
{
}
static void DummyMutexDestroy(PlatformSpecificMutex mtx)
{
}
PlatformSpecificMutex (*PlatformSpecificMutexCreate)(void) = DummyMutexCreate;
void (*PlatformSpecificMutexLock)(PlatformSpecificMutex) = DummyMutexLock;
void (*PlatformSpecificMutexUnlock)(PlatformSpecificMutex) = DummyMutexUnlock;
void (*PlatformSpecificMutexDestroy)(PlatformSpecificMutex) = DummyMutexDestroy;
static void DosAbort()
{
abort();
}
void (*PlatformSpecificAbort)(void) = DosAbort;
}
| null |
26 | cpp | cpputest | UtestPlatform.cpp | src/Platforms/armcc/UtestPlatform.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <time.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <setjmp.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include "CppUTest/TestHarness.h"
#undef malloc
#undef calloc
#undef realloc
#undef free
#undef strdup
#undef strndup
#define far // eliminate "meaningless type qualifier" warning
#include "CppUTest/PlatformSpecificFunctions.h"
static jmp_buf test_exit_jmp_buf[10];
static int jmp_buf_index = 0;
TestOutput::WorkingEnvironment PlatformSpecificGetWorkingEnvironment()
{
return TestOutput::eclipse;
}
static void DummyPlatformSpecificRunTestInASeperateProcess(UtestShell* shell, TestPlugin*, TestResult* result)
{
result->addFailure(TestFailure(shell, "-p doesn't work on this platform, as it is lacking fork.\b"));
}
static int DummyPlatformSpecificFork(void)
{
return 0;
}
static int DummyPlatformSpecificWaitPid(int, int*, int)
{
return 0;
}
void (*PlatformSpecificRunTestInASeperateProcess)(UtestShell* shell, TestPlugin* plugin, TestResult* result) =
DummyPlatformSpecificRunTestInASeperateProcess;
int (*PlatformSpecificFork)(void) = DummyPlatformSpecificFork;
int (*PlatformSpecificWaitPid)(int, int*, int) = DummyPlatformSpecificWaitPid;
extern "C" {
static int PlatformSpecificSetJmpImplementation(void (*function) (void* data), void* data)
{
if (0 == setjmp(test_exit_jmp_buf[jmp_buf_index])) {
jmp_buf_index++;
function(data);
jmp_buf_index--;
return 1;
}
return 0;
}
static void PlatformSpecificLongJmpImplementation()
{
jmp_buf_index--;
longjmp(test_exit_jmp_buf[jmp_buf_index], 1);
}
static void PlatformSpecificRestoreJumpBufferImplementation()
{
jmp_buf_index--;
}
void (*PlatformSpecificLongJmp)() = PlatformSpecificLongJmpImplementation;
int (*PlatformSpecificSetJmp)(void (*)(void*), void*) = PlatformSpecificSetJmpImplementation;
void (*PlatformSpecificRestoreJumpBuffer)() = PlatformSpecificRestoreJumpBufferImplementation;
///////////// Time in millis
/*
* In Keil MDK-ARM, clock() default implementation used semihosting.
* Resolutions is user adjustable (1 ms for now)
*/
static unsigned long TimeInMillisImplementation()
{
clock_t t = clock();
return (unsigned long)t;
}
///////////// Time in String
static const char* DummyTimeStringImplementation()
{
time_t tm = 0;
return ctime(&tm);
}
unsigned long (*GetPlatformSpecificTimeInMillis)() = TimeInMillisImplementation;
const char* (*GetPlatformSpecificTimeString)() = DummyTimeStringImplementation;
int (*PlatformSpecificVSNprintf)(char *str, size_t size, const char* format, va_list args) = vsnprintf;
static PlatformSpecificFile PlatformSpecificFOpenImplementation(const char* filename, const char* flag)
{
return fopen(filename, flag);
}
static void PlatformSpecificFPutsImplementation(const char* str, PlatformSpecificFile file)
{
fputs(str, (FILE*)file);
}
static void PlatformSpecificFCloseImplementation(PlatformSpecificFile file)
{
fclose((FILE*)file);
}
static void PlatformSpecificFlushImplementation()
{
fflush(stdout);
}
PlatformSpecificFile PlatformSpecificStdOut = stdout;
PlatformSpecificFile (*PlatformSpecificFOpen)(const char*, const char*) = PlatformSpecificFOpenImplementation;
void (*PlatformSpecificFPuts)(const char*, PlatformSpecificFile) = PlatformSpecificFPutsImplementation;
void (*PlatformSpecificFClose)(PlatformSpecificFile) = PlatformSpecificFCloseImplementation;
void (*PlatformSpecificFlush)() = PlatformSpecificFlushImplementation;
void* (*PlatformSpecificMalloc)(size_t size) = malloc;
void* (*PlatformSpecificRealloc)(void*, size_t) = realloc;
void (*PlatformSpecificFree)(void* memory) = free;
void* (*PlatformSpecificMemCpy)(void*, const void*, size_t) = memcpy;
void* (*PlatformSpecificMemset)(void*, int, size_t) = memset;
void (*PlatformSpecificSrand)(unsigned int) = srand;
int (*PlatformSpecificRand)(void) = rand;
static int IsNanImplementation(double d)
{
return isnan(d);
}
static int IsInfImplementation(double d)
{
return isinf(d);
}
static int AtExitImplementation(void(*func)(void))
{
return atexit(func);
}
double (*PlatformSpecificFabs)(double) = fabs;
int (*PlatformSpecificIsNan)(double) = IsNanImplementation;
int (*PlatformSpecificIsInf)(double) = IsInfImplementation;
int (*PlatformSpecificAtExit)(void(*func)(void)) = AtExitImplementation;
static PlatformSpecificMutex DummyMutexCreate(void)
{
return 0;
}
static void DummyMutexLock(PlatformSpecificMutex)
{
}
static void DummyMutexUnlock(PlatformSpecificMutex)
{
}
static void DummyMutexDestroy(PlatformSpecificMutex)
{
}
PlatformSpecificMutex (*PlatformSpecificMutexCreate)(void) = DummyMutexCreate;
void (*PlatformSpecificMutexLock)(PlatformSpecificMutex) = DummyMutexLock;
void (*PlatformSpecificMutexUnlock)(PlatformSpecificMutex) = DummyMutexUnlock;
void (*PlatformSpecificMutexDestroy)(PlatformSpecificMutex) = DummyMutexDestroy;
void (*PlatformSpecificAbort)(void) = abort;
}
| null |
27 | cpp | cpputest | UtestPlatform.cpp | src/Platforms/Gcc/UtestPlatform.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdlib.h>
#include "CppUTest/TestHarness.h"
#undef malloc
#undef free
#undef calloc
#undef realloc
#undef strdup
#undef strndup
#ifdef CPPUTEST_HAVE_GETTIMEOFDAY
#include <sys/time.h>
#endif
#if defined(CPPUTEST_HAVE_FORK) && defined(CPPUTEST_HAVE_WAITPID)
#include <unistd.h>
#include <sys/wait.h>
#include <errno.h>
#endif
#include <time.h>
#include <stdio.h>
#include <stdarg.h>
#include <setjmp.h>
#include <string.h>
#include <math.h>
#include <ctype.h>
#include <signal.h>
#ifdef CPPUTEST_HAVE_PTHREAD_MUTEX_LOCK
#include <pthread.h>
#endif
#include "CppUTest/PlatformSpecificFunctions.h"
static jmp_buf test_exit_jmp_buf[10];
static int jmp_buf_index = 0;
// There is a possibility that a compiler provides fork but not waitpid.
#if !defined(CPPUTEST_HAVE_FORK) || !defined(CPPUTEST_HAVE_WAITPID)
static void GccPlatformSpecificRunTestInASeperateProcess(UtestShell* shell, TestPlugin*, TestResult* result)
{
result->addFailure(TestFailure(shell, "-p doesn't work on this platform, as it is lacking fork.\b"));
}
static int PlatformSpecificForkImplementation(void)
{
return 0;
}
static int PlatformSpecificWaitPidImplementation(int, int*, int)
{
return 0;
}
#else
static void SetTestFailureByStatusCode(UtestShell* shell, TestResult* result, int status)
{
if (WIFEXITED(status) && WEXITSTATUS(status) != 0) {
result->addFailure(TestFailure(shell, "Failed in separate process"));
} else if (WIFSIGNALED(status)) {
SimpleString message("Failed in separate process - killed by signal ");
message += StringFrom(WTERMSIG(status));
result->addFailure(TestFailure(shell, message));
} else if (WIFSTOPPED(status)) {
result->addFailure(TestFailure(shell, "Stopped in separate process - continuing"));
}
}
static void GccPlatformSpecificRunTestInASeperateProcess(UtestShell* shell, TestPlugin* plugin, TestResult* result)
{
const pid_t syscallError = -1;
pid_t cpid;
pid_t w;
int status = 0;
cpid = PlatformSpecificFork();
if (cpid == syscallError) {
result->addFailure(TestFailure(shell, "Call to fork() failed"));
return;
}
if (cpid == 0) { /* Code executed by child */
const size_t initialFailureCount = result->getFailureCount(); // LCOV_EXCL_LINE
shell->runOneTestInCurrentProcess(plugin, *result); // LCOV_EXCL_LINE
_exit(initialFailureCount < result->getFailureCount()); // LCOV_EXCL_LINE
} else { /* Code executed by parent */
size_t amountOfRetries = 0;
do {
w = PlatformSpecificWaitPid(cpid, &status, WUNTRACED);
if (w == syscallError) {
// OS X debugger causes EINTR
if (EINTR == errno) {
if (amountOfRetries > 30) {
result->addFailure(TestFailure(shell, "Call to waitpid() failed with EINTR. Tried 30 times and giving up! Sometimes happens in debugger"));
return;
}
amountOfRetries++;
}
else {
result->addFailure(TestFailure(shell, "Call to waitpid() failed"));
return;
}
} else {
SetTestFailureByStatusCode(shell, result, status);
if (WIFSTOPPED(status)) kill(w, SIGCONT);
}
} while ((w == syscallError) || (!WIFEXITED(status) && !WIFSIGNALED(status)));
}
}
static pid_t PlatformSpecificForkImplementation(void)
{
return fork();
}
static pid_t PlatformSpecificWaitPidImplementation(int pid, int* status, int options)
{
return waitpid(pid, status, options);
}
#endif
TestOutput::WorkingEnvironment PlatformSpecificGetWorkingEnvironment()
{
return TestOutput::eclipse;
}
void (*PlatformSpecificRunTestInASeperateProcess)(UtestShell* shell, TestPlugin* plugin, TestResult* result) =
GccPlatformSpecificRunTestInASeperateProcess;
int (*PlatformSpecificFork)(void) = PlatformSpecificForkImplementation;
int (*PlatformSpecificWaitPid)(int, int*, int) = PlatformSpecificWaitPidImplementation;
extern "C" {
static int PlatformSpecificSetJmpImplementation(void (*function) (void* data), void* data)
{
if (0 == setjmp(test_exit_jmp_buf[jmp_buf_index])) {
jmp_buf_index++;
function(data);
jmp_buf_index--;
return 1;
}
return 0;
}
/*
* MacOSX clang 3.0 doesn't seem to recognize longjmp and thus complains about CPPUTEST_NORETURN.
* The later clang compilers complain when it isn't there. So only way is to check the clang compiler here :(
*/
#ifdef __clang__
#if !((__clang_major__ == 3) && (__clang_minor__ == 0))
CPPUTEST_NORETURN
#endif
#endif
static void PlatformSpecificLongJmpImplementation()
{
jmp_buf_index--;
longjmp(test_exit_jmp_buf[jmp_buf_index], 1);
}
static void PlatformSpecificRestoreJumpBufferImplementation()
{
jmp_buf_index--;
}
void (*PlatformSpecificLongJmp)() = PlatformSpecificLongJmpImplementation;
int (*PlatformSpecificSetJmp)(void (*)(void*), void*) = PlatformSpecificSetJmpImplementation;
void (*PlatformSpecificRestoreJumpBuffer)() = PlatformSpecificRestoreJumpBufferImplementation;
///////////// Time in millis
static unsigned long TimeInMillisImplementation()
{
#ifdef CPPUTEST_HAVE_GETTIMEOFDAY
struct timeval tv;
gettimeofday(&tv, NULL);
return (((unsigned long)tv.tv_sec * 1000) + ((unsigned long)tv.tv_usec / 1000));
#else
return 0;
#endif
}
static const char* TimeStringImplementation()
{
time_t theTime = time(NULLPTR);
static char dateTime[80];
#ifdef STDC_WANT_SECURE_LIB
static struct tm lastlocaltime;
localtime_s(&lastlocaltime, &theTime);
struct tm *tmp = &lastlocaltime;
#else
struct tm *tmp = localtime(&theTime);
#endif
strftime(dateTime, 80, "%Y-%m-%dT%H:%M:%S", tmp);
return dateTime;
}
unsigned long (*GetPlatformSpecificTimeInMillis)() = TimeInMillisImplementation;
const char* (*GetPlatformSpecificTimeString)() = TimeStringImplementation;
/* Wish we could add an attribute to the format for discovering mis-use... but the __attribute__(format) seems to not work on va_list */
#ifdef __clang__
#pragma clang diagnostic ignored "-Wformat-nonliteral"
#endif
#ifdef __clang__
#pragma clang diagnostic ignored "-Wused-but-marked-unused"
#endif
int (*PlatformSpecificVSNprintf)(char *str, size_t size, const char* format, va_list va_args_list) = vsnprintf;
static PlatformSpecificFile PlatformSpecificFOpenImplementation(const char* filename, const char* flag)
{
#ifdef STDC_WANT_SECURE_LIB
FILE* file;
fopen_s(&file, filename, flag);
return file;
#else
return fopen(filename, flag);
#endif
}
static void PlatformSpecificFPutsImplementation(const char* str, PlatformSpecificFile file)
{
fputs(str, (FILE*)file);
}
static void PlatformSpecificFCloseImplementation(PlatformSpecificFile file)
{
fclose((FILE*)file);
}
static void PlatformSpecificFlushImplementation()
{
fflush(stdout);
}
PlatformSpecificFile PlatformSpecificStdOut = stdout;
PlatformSpecificFile (*PlatformSpecificFOpen)(const char*, const char*) = PlatformSpecificFOpenImplementation;
void (*PlatformSpecificFPuts)(const char*, PlatformSpecificFile) = PlatformSpecificFPutsImplementation;
void (*PlatformSpecificFClose)(PlatformSpecificFile) = PlatformSpecificFCloseImplementation;
void (*PlatformSpecificFlush)() = PlatformSpecificFlushImplementation;
void* (*PlatformSpecificMalloc)(size_t size) = malloc;
void* (*PlatformSpecificRealloc)(void*, size_t) = realloc;
void (*PlatformSpecificFree)(void* memory) = free;
void* (*PlatformSpecificMemCpy)(void*, const void*, size_t) = memcpy;
void* (*PlatformSpecificMemset)(void*, int, size_t) = memset;
/* GCC 4.9.x introduces -Wfloat-conversion, which causes a warning / error
* in GCC's own (macro) implementation of isnan() and isinf().
*/
#if defined(__GNUC__) && (__GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ > 8))
#pragma GCC diagnostic ignored "-Wfloat-conversion"
#endif
static int IsNanImplementation(double d)
{
return isnan(d);
}
static int IsInfImplementation(double d)
{
return isinf(d);
}
double (*PlatformSpecificFabs)(double) = fabs;
void (*PlatformSpecificSrand)(unsigned int) = srand;
int (*PlatformSpecificRand)(void) = rand;
int (*PlatformSpecificIsNan)(double) = IsNanImplementation;
int (*PlatformSpecificIsInf)(double) = IsInfImplementation;
int (*PlatformSpecificAtExit)(void(*func)(void)) = atexit; /// this was undefined before
static PlatformSpecificMutex PThreadMutexCreate(void)
{
#ifdef CPPUTEST_HAVE_PTHREAD_MUTEX_LOCK
pthread_mutex_t *mutex = new pthread_mutex_t;
pthread_mutex_init(mutex, NULLPTR);
return (PlatformSpecificMutex)mutex;
#else
return NULLPTR;
#endif
}
#ifdef CPPUTEST_HAVE_PTHREAD_MUTEX_LOCK
static void PThreadMutexLock(PlatformSpecificMutex mtx)
{
pthread_mutex_lock((pthread_mutex_t *)mtx);
}
#else
static void PThreadMutexLock(PlatformSpecificMutex)
{
}
#endif
#ifdef CPPUTEST_HAVE_PTHREAD_MUTEX_LOCK
static void PThreadMutexUnlock(PlatformSpecificMutex mtx)
{
pthread_mutex_unlock((pthread_mutex_t *)mtx);
}
#else
static void PThreadMutexUnlock(PlatformSpecificMutex)
{
}
#endif
#ifdef CPPUTEST_HAVE_PTHREAD_MUTEX_LOCK
static void PThreadMutexDestroy(PlatformSpecificMutex mtx)
{
pthread_mutex_t *mutex = (pthread_mutex_t *)mtx;
pthread_mutex_destroy(mutex);
delete mutex;
}
#else
static void PThreadMutexDestroy(PlatformSpecificMutex)
{
}
#endif
PlatformSpecificMutex (*PlatformSpecificMutexCreate)(void) = PThreadMutexCreate;
void (*PlatformSpecificMutexLock)(PlatformSpecificMutex) = PThreadMutexLock;
void (*PlatformSpecificMutexUnlock)(PlatformSpecificMutex) = PThreadMutexUnlock;
void (*PlatformSpecificMutexDestroy)(PlatformSpecificMutex) = PThreadMutexDestroy;
void (*PlatformSpecificAbort)(void) = abort;
}
| null |
28 | cpp | cpputest | UtestPlatform.cpp | src/Platforms/Iar/UtestPlatform.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <time.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <setjmp.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include "CppUTest/TestHarness.h"
#undef malloc
#undef calloc
#undef realloc
#undef free
#undef strdup
#undef strndup
#include "CppUTest/PlatformSpecificFunctions.h"
static jmp_buf test_exit_jmp_buf[10];
static int jmp_buf_index = 0;
TestOutput::WorkingEnvironment PlatformSpecificGetWorkingEnvironment()
{
return TestOutput::eclipse;
}
static void DummyPlatformSpecificRunTestInASeperateProcess(UtestShell* shell, TestPlugin*, TestResult* result)
{
result->addFailure(TestFailure(shell, "-p doesn't work on this platform, as it is lacking fork.\b"));
}
static int DummyPlatformSpecificFork(void)
{
return 0;
}
static int DummyPlatformSpecificWaitPid(int, int*, int)
{
return 0;
}
void (*PlatformSpecificRunTestInASeperateProcess)(UtestShell* shell, TestPlugin* plugin, TestResult* result) =
DummyPlatformSpecificRunTestInASeperateProcess;
int (*PlatformSpecificFork)(void) = DummyPlatformSpecificFork;
int (*PlatformSpecificWaitPid)(int, int*, int) = DummyPlatformSpecificWaitPid;
extern "C" {
static int PlatformSpecificSetJmpImplementation(void (*function) (void* data), void* data)
{
if (0 == setjmp(test_exit_jmp_buf[jmp_buf_index])) {
jmp_buf_index++;
function(data);
jmp_buf_index--;
return 1;
}
return 0;
}
static void PlatformSpecificLongJmpImplementation()
{
jmp_buf_index--;
longjmp(test_exit_jmp_buf[jmp_buf_index], 1);
}
static void PlatformSpecificRestoreJumpBufferImplementation()
{
jmp_buf_index--;
}
void (*PlatformSpecificLongJmp)() = PlatformSpecificLongJmpImplementation;
int (*PlatformSpecificSetJmp)(void (*)(void*), void*) = PlatformSpecificSetJmpImplementation;
void (*PlatformSpecificRestoreJumpBuffer)() = PlatformSpecificRestoreJumpBufferImplementation;
///////////// Time in millis
static unsigned long TimeInMillisImplementation()
{
clock_t t = clock();
t = t * 10;
return (unsigned long)t;
}
///////////// Time in String
static const char* TimeStringImplementation()
{
time_t tm = time(NULL);
char* pTimeStr = ctime(&tm);
char* newlineChar = strchr(pTimeStr, '\n'); // Find the terminating newline character.
if(newlineChar != NULL) *newlineChar = '\0'; //If newline is found replace it with the string terminator.
return (pTimeStr);
}
unsigned long (*GetPlatformSpecificTimeInMillis)() = TimeInMillisImplementation;
const char* (*GetPlatformSpecificTimeString)() = TimeStringImplementation;
int (*PlatformSpecificVSNprintf)(char *str, size_t size, const char* format, va_list args) = vsnprintf;
static PlatformSpecificFile PlatformSpecificFOpenImplementation(const char* filename, const char* flag)
{
static int fileNo = 0;
(void)filename;
(void)flag;
fileNo++;
return (void*)fileNo;
}
static void PlatformSpecificFPutsImplementation(const char* str, PlatformSpecificFile file)
{
(void)str;
(void)file;
printf("FILE%d:%s",(int)file, str);
}
static void PlatformSpecificFCloseImplementation(PlatformSpecificFile file)
{
(void)file;
}
static void PlatformSpecificFlushImplementation()
{
}
PlatformSpecificFile PlatformSpecificStdOut = stdout;
PlatformSpecificFile (*PlatformSpecificFOpen)(const char*, const char*) = PlatformSpecificFOpenImplementation;
void (*PlatformSpecificFPuts)(const char*, PlatformSpecificFile) = PlatformSpecificFPutsImplementation;
void (*PlatformSpecificFClose)(PlatformSpecificFile) = PlatformSpecificFCloseImplementation;
void (*PlatformSpecificFlush)() = PlatformSpecificFlushImplementation;
void* (*PlatformSpecificMalloc)(size_t size) = malloc;
void* (*PlatformSpecificRealloc)(void*, size_t) = realloc;
void (*PlatformSpecificFree)(void* memory) = free;
void* (*PlatformSpecificMemCpy)(void*, const void*, size_t) = memcpy;
void* (*PlatformSpecificMemset)(void*, int, size_t) = memset;
static int IsNanImplementation(double d)
{
return isnan(d);
}
static int IsInfImplementation(double d)
{
return isinf(d);
}
double (*PlatformSpecificFabs)(double) = fabs;
int (*PlatformSpecificIsNan)(double) = IsNanImplementation;
int (*PlatformSpecificIsInf)(double) = IsInfImplementation;
int (*PlatformSpecificAtExit)(void(*func)(void)) = atexit; /// this was undefined before
static PlatformSpecificMutex DummyMutexCreate(void)
{
return 0;
}
static void DummyMutexLock(PlatformSpecificMutex)
{
}
static void DummyMutexUnlock(PlatformSpecificMutex)
{
}
static void DummyMutexDestroy(PlatformSpecificMutex)
{
}
PlatformSpecificMutex (*PlatformSpecificMutexCreate)(void) = DummyMutexCreate;
void (*PlatformSpecificMutexLock)(PlatformSpecificMutex) = DummyMutexLock;
void (*PlatformSpecificMutexUnlock)(PlatformSpecificMutex) = DummyMutexUnlock;
void (*PlatformSpecificMutexDestroy)(PlatformSpecificMutex) = DummyMutexDestroy;
void (*PlatformSpecificSrand)(unsigned int) = srand;
int (*PlatformSpecificRand)(void) = rand;
void (*PlatformSpecificAbort)(void) = abort;
}
| null |
29 | cpp | cpputest | UtestPlatform.cpp | src/Platforms/Keil/UtestPlatform.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdlib.h>
#include "CppUTest/TestHarness.h"
#undef malloc
#undef free
#undef calloc
#undef realloc
#undef strdup
#undef strndup
#define far // eliminate "meaningless type qualifier" warning
#include <time.h>
#include <stdio.h>
#include <stdarg.h>
#include <setjmp.h>
#include <string.h>
#include <math.h>
#include <ctype.h>
#include "CppUTest/PlatformSpecificFunctions.h"
static jmp_buf test_exit_jmp_buf[10];
static int jmp_buf_index = 0;
TestOutput::WorkingEnvironment PlatformSpecificGetWorkingEnvironment()
{
return TestOutput::eclipse;
}
static void DummyRunTestInASeperateProcess(UtestShell* shell, TestPlugin* plugin, TestResult* result)
{
result->addFailure(TestFailure(shell, "-p doesn't work on this platform, as it is lacking fork.\b"));
}
static int DummyPlatformSpecificFork(void)
{
return 0;
}
static int DummyPlatformSpecificWaitPid(int, int*, int)
{
return 0;
}
void (*PlatformSpecificRunTestInASeperateProcess)(UtestShell*, TestPlugin*, TestResult*) = DummyRunTestInASeperateProcess;
int (*PlatformSpecificFork)() = DummyPlatformSpecificFork;
int (*PlatformSpecificWaitPid)(int, int*, int) = DummyPlatformSpecificWaitPid;
extern "C"
{
static int PlatformSpecificSetJmpImplementation(void (*function) (void* data), void* data)
{
if (0 == setjmp(test_exit_jmp_buf[jmp_buf_index])) {
jmp_buf_index++;
function(data);
jmp_buf_index--;
return 1;
}
return 0;
}
static void PlatformSpecificLongJmpImplementation()
{
jmp_buf_index--;
longjmp(test_exit_jmp_buf[jmp_buf_index], 1);
}
static void PlatformSpecificRestoreJumpBufferImplementation()
{
jmp_buf_index--;
}
void (*PlatformSpecificLongJmp)() = PlatformSpecificLongJmpImplementation;
int (*PlatformSpecificSetJmp)(void (*function)(void*), void*) = PlatformSpecificSetJmpImplementation;
void (*PlatformSpecificRestoreJumpBuffer)() = PlatformSpecificRestoreJumpBufferImplementation;
///////////// Time in millis
/*
* In Keil MDK-ARM, clock() default implementation used semihosting.
* Resolutions is user adjustable (1 ms for now)
*/
static unsigned long TimeInMillisImplementation()
{
clock_t t = clock();
t = t * 10;
return (unsigned long)t;
}
unsigned long (*GetPlatformSpecificTimeInMillis)() = TimeInMillisImplementation;
static const char* TimeStringImplementation()
{
time_t tm = 0;//time(NULL); // todo
return ctime(&tm);
}
const char* (*GetPlatformSpecificTimeString)() = TimeStringImplementation;
int PlatformSpecificAtoI(const char* str)
{
return atoi(str);
}
/* The ARMCC compiler will compile this function with C++ linkage, unless
* we specifically tell it to use C linkage again, in the function definiton.
*/
extern int (*PlatformSpecificVSNprintf)(char *str, size_t size, const char* format, va_list args) = vsnprintf;
static PlatformSpecificFile PlatformSpecificFOpenImplementation(const char* filename, const char* flag)
{
return 0;
}
static void PlatformSpecificFPutsImplementation(const char* str, PlatformSpecificFile file)
{
printf("%s", str);
}
static void PlatformSpecificFCloseImplementation(PlatformSpecificFile file)
{
}
static void PlatformSpecificFlushImplementation()
{
}
PlatformSpecificFile PlatformSpecificStdOut = stdout;
PlatformSpecificFile (*PlatformSpecificFOpen)(const char*, const char*) = PlatformSpecificFOpenImplementation;
void (*PlatformSpecificFPuts)(const char*, PlatformSpecificFile) = PlatformSpecificFPutsImplementation;
void (*PlatformSpecificFClose)(PlatformSpecificFile) = PlatformSpecificFCloseImplementation;
void (*PlatformSpecificFlush)() = PlatformSpecificFlushImplementation;
void* (*PlatformSpecificMalloc)(size_t) = malloc;
void* (*PlatformSpecificRealloc) (void*, size_t) = realloc;
void (*PlatformSpecificFree)(void*) = free;
void* (*PlatformSpecificMemCpy)(void* s1, const void* s2, size_t size) = memcpy;
void* (*PlatformSpecificMemset)(void*, int, size_t) = memset;
static int IsNanImplementation(double d)
{
# ifdef __MICROLIB
return 0;
# else
return isnan(d);
# endif
}
static int IsInfImplementation(double d)
{
# ifdef __MICROLIB
return 0;
# else
return isinf(d);
# endif
}
int DummyAtExit(void(*)(void))
{
return 0;
}
double (*PlatformSpecificFabs)(double) = abs;
int (*PlatformSpecificIsNan)(double) = IsNanImplementation;
int (*PlatformSpecificIsInf)(double) = IsInfImplementation;
int (*PlatformSpecificAtExit)(void(*func)(void)) = DummyAtExit;
static PlatformSpecificMutex DummyMutexCreate(void)
{
return 0;
}
static void DummyMutexLock(PlatformSpecificMutex mtx)
{
}
static void DummyMutexUnlock(PlatformSpecificMutex mtx)
{
}
static void DummyMutexDestroy(PlatformSpecificMutex mtx)
{
}
PlatformSpecificMutex (*PlatformSpecificMutexCreate)(void) = DummyMutexCreate;
void (*PlatformSpecificMutexLock)(PlatformSpecificMutex) = DummyMutexLock;
void (*PlatformSpecificMutexUnlock)(PlatformSpecificMutex) = DummyMutexUnlock;
void (*PlatformSpecificMutexDestroy)(PlatformSpecificMutex) = DummyMutexDestroy;
void (*PlatformSpecificAbort)(void) = abort;
}
| null |
30 | cpp | cpputest | UtestPlatform.cpp | src/Platforms/Borland/UtestPlatform.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdlib.h>
#include "CppUTest/TestHarness.h"
#undef malloc
#undef free
#undef calloc
#undef realloc
#undef strdup
#undef strndup
#ifdef CPPUTEST_HAVE_GETTIMEOFDAY
#include <sys/time.h>
#endif
#if defined(CPPUTEST_HAVE_FORK) && defined(CPPUTEST_HAVE_WAITPID)
#include <unistd.h>
#include <sys/wait.h>
#include <errno.h>
#endif
#include <time.h>
#include <stdio.h>
#include <stdarg.h>
#include <setjmp.h>
#include <string.h>
#include <math.h>
#include <float.h>
#include <ctype.h>
#include <signal.h>
#ifdef CPPUTEST_HAVE_PTHREAD_MUTEX_LOCK
#include <pthread.h>
#endif
#include "CppUTest/PlatformSpecificFunctions.h"
const std::nothrow_t std::nothrow;
static jmp_buf test_exit_jmp_buf[10];
static int jmp_buf_index = 0;
// There is a possibility that a compiler provides fork but not waitpid.
// TODO consider using spawn() and cwait()?
#if !defined(CPPUTEST_HAVE_FORK) || !defined(CPPUTEST_HAVE_WAITPID)
static void BorlandPlatformSpecificRunTestInASeperateProcess(UtestShell* shell, TestPlugin*, TestResult* result)
{
result->addFailure(TestFailure(shell, "-p doesn't work on this platform, as it is lacking fork.\b"));
}
static int PlatformSpecificForkImplementation(void)
{
return 0;
}
static int PlatformSpecificWaitPidImplementation(int, int*, int)
{
return 0;
}
#else
static void SetTestFailureByStatusCode(UtestShell* shell, TestResult* result, int status)
{
if (WIFEXITED(status) && WEXITSTATUS(status) != 0) {
result->addFailure(TestFailure(shell, "Failed in separate process"));
} else if (WIFSIGNALED(status)) {
SimpleString message("Failed in separate process - killed by signal ");
message += StringFrom(WTERMSIG(status));
result->addFailure(TestFailure(shell, message));
} else if (WIFSTOPPED(status)) {
result->addFailure(TestFailure(shell, "Stopped in separate process - continuing"));
}
}
static void BorlandPlatformSpecificRunTestInASeperateProcess(UtestShell* shell, TestPlugin* plugin, TestResult* result)
{
const pid_t syscallError = -1;
pid_t cpid;
pid_t w;
int status = 0;
cpid = PlatformSpecificFork();
if (cpid == syscallError) {
result->addFailure(TestFailure(shell, "Call to fork() failed"));
return;
}
if (cpid == 0) { /* Code executed by child */
const size_t initialFailureCount = result->getFailureCount(); // LCOV_EXCL_LINE
shell->runOneTestInCurrentProcess(plugin, *result); // LCOV_EXCL_LINE
_exit(initialFailureCount < result->getFailureCount()); // LCOV_EXCL_LINE
} else { /* Code executed by parent */
size_t amountOfRetries = 0;
do {
w = PlatformSpecificWaitPid(cpid, &status, WUNTRACED);
if (w == syscallError) {
// OS X debugger causes EINTR
if (EINTR == errno) {
if (amountOfRetries > 30) {
result->addFailure(TestFailure(shell, "Call to waitpid() failed with EINTR. Tried 30 times and giving up! Sometimes happens in debugger"));
return;
}
amountOfRetries++;
}
else {
result->addFailure(TestFailure(shell, "Call to waitpid() failed"));
return;
}
} else {
SetTestFailureByStatusCode(shell, result, status);
if (WIFSTOPPED(status)) kill(w, SIGCONT);
}
} while ((w == syscallError) || (!WIFEXITED(status) && !WIFSIGNALED(status)));
}
}
static pid_t PlatformSpecificForkImplementation(void)
{
return fork();
}
static pid_t PlatformSpecificWaitPidImplementation(int pid, int* status, int options)
{
return waitpid(pid, status, options);
}
#endif
TestOutput::WorkingEnvironment PlatformSpecificGetWorkingEnvironment()
{
return TestOutput::eclipse;
}
void (*PlatformSpecificRunTestInASeperateProcess)(UtestShell* shell, TestPlugin* plugin, TestResult* result) =
BorlandPlatformSpecificRunTestInASeperateProcess;
int (*PlatformSpecificFork)(void) = PlatformSpecificForkImplementation;
int (*PlatformSpecificWaitPid)(int, int*, int) = PlatformSpecificWaitPidImplementation;
extern "C" {
static int PlatformSpecificSetJmpImplementation(void (*function) (void* data), void* data)
{
if (0 == setjmp(test_exit_jmp_buf[jmp_buf_index])) {
jmp_buf_index++;
function(data);
jmp_buf_index--;
return 1;
}
return 0;
}
static void PlatformSpecificLongJmpImplementation()
{
jmp_buf_index--;
longjmp(test_exit_jmp_buf[jmp_buf_index], 1);
}
static void PlatformSpecificRestoreJumpBufferImplementation()
{
jmp_buf_index--;
}
void (*PlatformSpecificLongJmp)() = PlatformSpecificLongJmpImplementation;
int (*PlatformSpecificSetJmp)(void (*)(void*), void*) = PlatformSpecificSetJmpImplementation;
void (*PlatformSpecificRestoreJumpBuffer)() = PlatformSpecificRestoreJumpBufferImplementation;
///////////// Time in millis
static unsigned long TimeInMillisImplementation()
{
#ifdef CPPUTEST_HAVE_GETTIMEOFDAY
struct timeval tv;
gettimeofday(&tv, NULL);
return ((unsigned long)tv.tv_sec * 1000) + ((unsigned long)tv.tv_usec / 1000));
#else
return 0;
#endif
}
static const char* TimeStringImplementation()
{
time_t theTime = time(NULLPTR);
static char dateTime[80];
struct tm *tmp = localtime(&theTime);
strftime(dateTime, 80, "%Y-%m-%dT%H:%M:%S", tmp);
return dateTime;
}
unsigned long (*GetPlatformSpecificTimeInMillis)() = TimeInMillisImplementation;
const char* (*GetPlatformSpecificTimeString)() = TimeStringImplementation;
static int BorlandVSNprintf(char *str, size_t size, const char* format, va_list args)
{
int result = vsnprintf( str, size, format, args);
str[size-1] = 0;
return result;
}
int (*PlatformSpecificVSNprintf)(char *str, size_t size, const char* format, va_list va_args_list) = BorlandVSNprintf;
static PlatformSpecificFile PlatformSpecificFOpenImplementation(const char* filename, const char* flag)
{
return fopen(filename, flag);
}
static void PlatformSpecificFPutsImplementation(const char* str, PlatformSpecificFile file)
{
fputs(str, (FILE*)file);
}
static void PlatformSpecificFCloseImplementation(PlatformSpecificFile file)
{
fclose((FILE*)file);
}
static void PlatformSpecificFlushImplementation()
{
fflush(stdout);
}
PlatformSpecificFile PlatformSpecificStdOut = stdout;
PlatformSpecificFile (*PlatformSpecificFOpen)(const char*, const char*) = PlatformSpecificFOpenImplementation;
void (*PlatformSpecificFPuts)(const char*, PlatformSpecificFile) = PlatformSpecificFPutsImplementation;
void (*PlatformSpecificFClose)(PlatformSpecificFile) = PlatformSpecificFCloseImplementation;
void (*PlatformSpecificFlush)() = PlatformSpecificFlushImplementation;
void* (*PlatformSpecificMalloc)(size_t size) = malloc;
void* (*PlatformSpecificRealloc)(void*, size_t) = realloc;
void (*PlatformSpecificFree)(void* memory) = free;
void* (*PlatformSpecificMemCpy)(void*, const void*, size_t) = memcpy;
void* (*PlatformSpecificMemset)(void*, int, size_t) = memset;
static int IsNanImplementation(double d)
{
return _isnan(d);
}
static int IsInfImplementation(double d)
{
return !(_finite(d) || _isnan(d));
}
double (*PlatformSpecificFabs)(double) = fabs;
void (*PlatformSpecificSrand)(unsigned int) = srand;
int (*PlatformSpecificRand)(void) = rand;
int (*PlatformSpecificIsNan)(double) = IsNanImplementation;
int (*PlatformSpecificIsInf)(double) = IsInfImplementation;
int (*PlatformSpecificAtExit)(void(*func)(void)) = atexit; /// this was undefined before
static PlatformSpecificMutex PThreadMutexCreate(void)
{
#ifdef CPPUTEST_HAVE_PTHREAD_MUTEX_LOCK
pthread_mutex_t *mutex = new pthread_mutex_t;
pthread_mutex_init(mutex, NULLPTR);
return (PlatformSpecificMutex)mutex;
#else
return NULLPTR;
#endif
}
#ifdef CPPUTEST_HAVE_PTHREAD_MUTEX_LOCK
static void PThreadMutexLock(PlatformSpecificMutex mtx)
{
pthread_mutex_lock((pthread_mutex_t *)mtx);
}
#else
static void PThreadMutexLock(PlatformSpecificMutex)
{
}
#endif
#ifdef CPPUTEST_HAVE_PTHREAD_MUTEX_LOCK
static void PThreadMutexUnlock(PlatformSpecificMutex mtx)
{
pthread_mutex_unlock((pthread_mutex_t *)mtx);
}
#else
static void PThreadMutexUnlock(PlatformSpecificMutex)
{
}
#endif
#ifdef CPPUTEST_HAVE_PTHREAD_MUTEX_LOCK
static void PThreadMutexDestroy(PlatformSpecificMutex mtx)
{
pthread_mutex_t *mutex = (pthread_mutex_t *)mtx;
pthread_mutex_destroy(mutex);
delete mutex;
}
#else
static void PThreadMutexDestroy(PlatformSpecificMutex)
{
}
#endif
PlatformSpecificMutex (*PlatformSpecificMutexCreate)(void) = PThreadMutexCreate;
void (*PlatformSpecificMutexLock)(PlatformSpecificMutex) = PThreadMutexLock;
void (*PlatformSpecificMutexUnlock)(PlatformSpecificMutex) = PThreadMutexUnlock;
void (*PlatformSpecificMutexDestroy)(PlatformSpecificMutex) = PThreadMutexDestroy;
void (*PlatformSpecificAbort)(void) = abort;
}
| null |
31 | cpp | cpputest | MemoryReportFormatter.cpp | src/CppUTestExt/MemoryReportFormatter.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/TestHarness.h"
#include "CppUTestExt/MemoryReportAllocator.h"
#include "CppUTestExt/MemoryReportFormatter.h"
NormalMemoryReportFormatter::NormalMemoryReportFormatter()
{
}
NormalMemoryReportFormatter::~NormalMemoryReportFormatter()
{
}
void NormalMemoryReportFormatter::report_test_start(TestResult* result, UtestShell& test)
{
result->print(StringFromFormat("TEST(%s, %s)\n", test.getGroup().asCharString(), test.getName().asCharString()).asCharString());
}
void NormalMemoryReportFormatter::report_test_end(TestResult* result, UtestShell& test)
{
result->print(StringFromFormat("ENDTEST(%s, %s)\n", test.getGroup().asCharString(), test.getName().asCharString()).asCharString());
}
void NormalMemoryReportFormatter::report_alloc_memory(TestResult* result, TestMemoryAllocator* allocator, size_t size, char* memory, const char* file, size_t line)
{
result->print(StringFromFormat("\tAllocation using %s of size: %lu pointer: %p at %s:%d\n", allocator->alloc_name(), (unsigned long) size, (void*) memory, file, (int) line).asCharString());
}
void NormalMemoryReportFormatter::report_free_memory(TestResult* result, TestMemoryAllocator* allocator, char* memory, const char* file, size_t line)
{
result->print(StringFromFormat("\tDeallocation using %s of pointer: %p at %s:%d\n", allocator->free_name(), (void*) memory, file, (int) line).asCharString());
}
void NormalMemoryReportFormatter::report_testgroup_start(TestResult* result, UtestShell& test)
{
const size_t line_size = 80;
SimpleString groupName = StringFromFormat("TEST GROUP(%s)", test.getGroup().asCharString());
size_t beginPos = (line_size/2) - (groupName.size()/2);
SimpleString line("-", beginPos);
line += groupName;
line += SimpleString("-", line_size - line.size());
line += "\n";
result->print(line.asCharString());
}
| null |
32 | cpp | cpputest | MemoryReporterPlugin.cpp | src/CppUTestExt/MemoryReporterPlugin.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/TestHarness.h"
#include "CppUTestExt/MemoryReporterPlugin.h"
#include "CppUTestExt/MemoryReportFormatter.h"
#include "CppUTestExt/CodeMemoryReportFormatter.h"
MemoryReporterPlugin::MemoryReporterPlugin()
: TestPlugin("MemoryReporterPlugin"), formatter_(NULLPTR)
{
}
MemoryReporterPlugin::~MemoryReporterPlugin()
{
removeGlobalMemoryReportAllocators();
destroyMemoryFormatter(formatter_);
}
bool MemoryReporterPlugin::parseArguments(int /* ac */, const char *const *av, int index)
{
SimpleString argument (av[index]);
if (argument.contains("-pmemoryreport=")) {
argument.replace("-pmemoryreport=", "");
destroyMemoryFormatter(formatter_);
formatter_ = createMemoryFormatter(argument);
return true;
}
return false;
}
MemoryReportFormatter* MemoryReporterPlugin::createMemoryFormatter(const SimpleString& type)
{
if (type == "normal") {
return new NormalMemoryReportFormatter;
}
else if (type == "code") {
return new CodeMemoryReportFormatter(defaultMallocAllocator());
}
return NULLPTR;
}
void MemoryReporterPlugin::destroyMemoryFormatter(MemoryReportFormatter* formatter)
{
delete formatter;
}
void MemoryReporterPlugin::setGlobalMemoryReportAllocators()
{
mallocAllocator.setRealAllocator(getCurrentMallocAllocator());
setCurrentMallocAllocator(&mallocAllocator);
newAllocator.setRealAllocator(getCurrentNewAllocator());
setCurrentNewAllocator(&newAllocator);
newArrayAllocator.setRealAllocator(getCurrentNewArrayAllocator());
setCurrentNewArrayAllocator(&newArrayAllocator);
}
void MemoryReporterPlugin::removeGlobalMemoryReportAllocators()
{
if (getCurrentNewAllocator() == &newAllocator)
setCurrentNewAllocator(newAllocator.getRealAllocator());
if (getCurrentNewArrayAllocator() == &newArrayAllocator)
setCurrentNewArrayAllocator(newArrayAllocator.getRealAllocator());
if (getCurrentMallocAllocator() == &mallocAllocator)
setCurrentMallocAllocator(mallocAllocator.getRealAllocator());
}
MemoryReportAllocator* MemoryReporterPlugin::getMallocAllocator()
{
return &mallocAllocator;
}
MemoryReportAllocator* MemoryReporterPlugin::getNewAllocator()
{
return &newAllocator;
}
MemoryReportAllocator* MemoryReporterPlugin::getNewArrayAllocator()
{
return &newArrayAllocator;
}
void MemoryReporterPlugin::initializeAllocator(MemoryReportAllocator* allocator, TestResult & result)
{
allocator->setFormatter(formatter_);
allocator->setTestResult((&result));
}
void MemoryReporterPlugin::preTestAction(UtestShell& test, TestResult& result)
{
if (formatter_ == NULLPTR) return;
initializeAllocator(&mallocAllocator, result);
initializeAllocator(&newAllocator, result);
initializeAllocator(&newArrayAllocator, result);
setGlobalMemoryReportAllocators();
if (test.getGroup() != currentTestGroup_) {
formatter_->report_testgroup_start(&result, test);
currentTestGroup_ = test.getGroup();
}
formatter_->report_test_start(&result, test);
}
void MemoryReporterPlugin::postTestAction(UtestShell& test, TestResult& result)
{
if (formatter_ == NULLPTR) return;
removeGlobalMemoryReportAllocators();
formatter_->report_test_end(&result, test);
if (test.getNext() == NULLPTR || test.getNext()->getGroup() != currentTestGroup_)
formatter_->report_testgroup_end(&result, test);
}
| null |
33 | cpp | cpputest | MockFailure.cpp | src/CppUTestExt/MockFailure.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/TestHarness.h"
#include "CppUTestExt/MockFailure.h"
#include "CppUTestExt/MockExpectedCall.h"
#include "CppUTestExt/MockExpectedCallsList.h"
#include "CppUTestExt/MockNamedValue.h"
class MockFailureReporterTestTerminator : public TestTerminator
{
public:
MockFailureReporterTestTerminator(bool crashOnFailure) : crashOnFailure_(crashOnFailure)
{
}
virtual void exitCurrentTest() const CPPUTEST_OVERRIDE
{
if (crashOnFailure_)
UT_CRASH();
UtestShell::getCurrentTestTerminator().exitCurrentTest();
} // LCOV_EXCL_LINE
virtual ~MockFailureReporterTestTerminator() CPPUTEST_DESTRUCTOR_OVERRIDE
{
}
private:
bool crashOnFailure_;
};
void MockFailureReporter::failTest(const MockFailure& failure)
{
if (!getTestToFail()->hasFailed())
getTestToFail()->failWith(failure, MockFailureReporterTestTerminator(crashOnFailure_));
} // LCOV_EXCL_LINE
UtestShell* MockFailureReporter::getTestToFail()
{
return UtestShell::getCurrent();
}
MockFailure::MockFailure(UtestShell* test) : TestFailure(test, "Test failed with MockFailure without an error! Something went seriously wrong.")
{
}
void MockFailure::addExpectationsAndCallHistory(const MockExpectedCallsList& expectations)
{
message_ += "\tEXPECTED calls that WERE NOT fulfilled:\n";
message_ += expectations.unfulfilledCallsToString("\t\t");
message_ += "\n\tEXPECTED calls that WERE fulfilled:\n";
message_ += expectations.fulfilledCallsToString("\t\t");
}
void MockFailure::addExpectationsAndCallHistoryRelatedTo(const SimpleString& name, const MockExpectedCallsList& expectations)
{
MockExpectedCallsList expectationsForFunction;
expectationsForFunction.addExpectationsRelatedTo(name, expectations);
message_ += "\tEXPECTED calls that WERE NOT fulfilled related to function: ";
message_ += name;
message_ += "\n";
message_ += expectationsForFunction.unfulfilledCallsToString("\t\t");
message_ += "\n\tEXPECTED calls that WERE fulfilled related to function: ";
message_ += name;
message_ += "\n";
message_ += expectationsForFunction.fulfilledCallsToString("\t\t");
}
MockExpectedCallsDidntHappenFailure::MockExpectedCallsDidntHappenFailure(UtestShell* test, const MockExpectedCallsList& expectations) : MockFailure(test)
{
message_ = "Mock Failure: Expected call WAS NOT fulfilled.\n";
addExpectationsAndCallHistory(expectations);
}
MockUnexpectedCallHappenedFailure::MockUnexpectedCallHappenedFailure(UtestShell* test, const SimpleString& name, const MockExpectedCallsList& expectations) : MockFailure(test)
{
unsigned int amountOfActualCalls = expectations.amountOfActualCallsFulfilledFor(name);
if (amountOfActualCalls > 0) {
SimpleString ordinalNumber = StringFromOrdinalNumber(amountOfActualCalls + 1);
message_ = StringFromFormat("Mock Failure: Unexpected additional (%s) call to function: ", ordinalNumber.asCharString());
} else {
message_ = "Mock Failure: Unexpected call to function: ";
}
message_ += name;
message_ += "\n";
addExpectationsAndCallHistory(expectations);
}
MockCallOrderFailure::MockCallOrderFailure(UtestShell* test, const MockExpectedCallsList& expectations) : MockFailure(test)
{
MockExpectedCallsList expectationsForOutOfOrder;
expectationsForOutOfOrder.addExpectations(expectations);
expectationsForOutOfOrder.onlyKeepOutOfOrderExpectations();
message_ = "Mock Failure: Out of order calls";
message_ += "\n";
addExpectationsAndCallHistory(expectationsForOutOfOrder);
}
MockUnexpectedInputParameterFailure::MockUnexpectedInputParameterFailure(UtestShell* test, const SimpleString& functionName, const MockNamedValue& parameter, const MockExpectedCallsList& expectations) : MockFailure(test)
{
MockExpectedCallsList expectationsForFunctionWithParameterName;
expectationsForFunctionWithParameterName.addExpectationsRelatedTo(functionName, expectations);
expectationsForFunctionWithParameterName.onlyKeepExpectationsWithInputParameterName(parameter.getName());
if (expectationsForFunctionWithParameterName.isEmpty()) {
message_ = "Mock Failure: Unexpected parameter name to function \"";
message_ += functionName;
message_ += "\": ";
message_ += parameter.getName();
}
else {
message_ = "Mock Failure: Unexpected parameter value to parameter \"";
message_ += parameter.getName();
message_ += "\" to function \"";
message_ += functionName;
message_ += "\": <";
message_ += StringFrom(parameter);
message_ += ">";
}
message_ += "\n";
addExpectationsAndCallHistoryRelatedTo(functionName, expectations);
message_ += "\n\tACTUAL unexpected parameter passed to function: ";
message_ += functionName;
message_ += "\n";
message_ += "\t\t";
message_ += parameter.getType();
message_ += " ";
message_ += parameter.getName();
message_ += ": <";
message_ += StringFrom(parameter);
message_ += ">";
}
MockUnexpectedOutputParameterFailure::MockUnexpectedOutputParameterFailure(UtestShell* test, const SimpleString& functionName, const MockNamedValue& parameter, const MockExpectedCallsList& expectations) : MockFailure(test)
{
MockExpectedCallsList expectationsForFunctionWithParameterName;
expectationsForFunctionWithParameterName.addExpectationsRelatedTo(functionName, expectations);
expectationsForFunctionWithParameterName.onlyKeepExpectationsWithOutputParameterName(parameter.getName());
if (expectationsForFunctionWithParameterName.isEmpty()) {
message_ = "Mock Failure: Unexpected output parameter name to function \"";
message_ += functionName;
message_ += "\": ";
message_ += parameter.getName();
}
else {
message_ = "Mock Failure: Unexpected parameter type \"";
message_ += parameter.getType();
message_ += "\" to output parameter \"";
message_ += parameter.getName();
message_ += "\" to function \"";
message_ += functionName;
message_ += "\"";
}
message_ += "\n";
addExpectationsAndCallHistoryRelatedTo(functionName, expectations);
message_ += "\n\tACTUAL unexpected output parameter passed to function: ";
message_ += functionName;
message_ += "\n";
message_ += "\t\t";
message_ += parameter.getType();
message_ += " ";
message_ += parameter.getName();
}
MockExpectedParameterDidntHappenFailure::MockExpectedParameterDidntHappenFailure(UtestShell* test, const SimpleString& functionName,
const MockExpectedCallsList& allExpectations,
const MockExpectedCallsList& matchingExpectations) : MockFailure(test)
{
message_ = "Mock Failure: Expected parameter for function \"";
message_ += functionName;
message_ += "\" did not happen.\n";
message_ += "\tEXPECTED calls with MISSING parameters related to function: ";
message_ += functionName;
message_ += "\n";
message_ += matchingExpectations.callsWithMissingParametersToString("\t\t", "\tMISSING parameters: ");
message_ += "\n";
addExpectationsAndCallHistoryRelatedTo(functionName, allExpectations);
}
MockNoWayToCompareCustomTypeFailure::MockNoWayToCompareCustomTypeFailure(UtestShell* test, const SimpleString& typeName) : MockFailure(test)
{
message_ = StringFromFormat("MockFailure: No way to compare type <%s>. Please install a MockNamedValueComparator.", typeName.asCharString());
}
MockNoWayToCopyCustomTypeFailure::MockNoWayToCopyCustomTypeFailure(UtestShell* test, const SimpleString& typeName) : MockFailure(test)
{
message_ = StringFromFormat("MockFailure: No way to copy type <%s>. Please install a MockNamedValueCopier.", typeName.asCharString());
}
MockUnexpectedObjectFailure::MockUnexpectedObjectFailure(UtestShell* test, const SimpleString& functionName, const void* actual, const MockExpectedCallsList& expectations) : MockFailure(test)
{
message_ = StringFromFormat ("MockFailure: Function called on an unexpected object: %s\n"
"\tActual object for call has address: <%p>\n", functionName.asCharString(),actual);
addExpectationsAndCallHistoryRelatedTo(functionName, expectations);
}
MockExpectedObjectDidntHappenFailure::MockExpectedObjectDidntHappenFailure(UtestShell* test, const SimpleString& functionName, const MockExpectedCallsList& expectations) : MockFailure(test)
{
message_ = StringFromFormat("Mock Failure: Expected call on object for function \"%s\" but it did not happen.\n", functionName.asCharString());
addExpectationsAndCallHistoryRelatedTo(functionName, expectations);
}
| null |
34 | cpp | cpputest | MockActualCall.cpp | src/CppUTestExt/MockActualCall.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/TestHarness.h"
#include "CppUTestExt/MockCheckedActualCall.h"
#include "CppUTestExt/MockCheckedExpectedCall.h"
#include "CppUTestExt/MockFailure.h"
#include "CppUTest/PlatformSpecificFunctions.h"
MockActualCall::MockActualCall()
{
}
MockActualCall::~MockActualCall()
{
}
void MockCheckedActualCall::setName(const SimpleString& name)
{
functionName_ = name;
}
SimpleString MockCheckedActualCall::getName() const
{
return functionName_;
}
MockCheckedActualCall::MockCheckedActualCall(unsigned int callOrder, MockFailureReporter* reporter, const MockExpectedCallsList& allExpectations)
: callOrder_(callOrder), reporter_(reporter), state_(CALL_SUCCEED), expectationsChecked_(false), matchingExpectation_(NULLPTR),
allExpectations_(allExpectations), outputParameterExpectations_(NULLPTR)
{
potentiallyMatchingExpectations_.addPotentiallyMatchingExpectations(allExpectations);
}
MockCheckedActualCall::~MockCheckedActualCall()
{
cleanUpOutputParameterList();
}
void MockCheckedActualCall::setMockFailureReporter(MockFailureReporter* reporter)
{
reporter_ = reporter;
}
UtestShell* MockCheckedActualCall::getTest() const
{
return reporter_->getTestToFail();
}
void MockCheckedActualCall::failTest(const MockFailure& failure)
{
if (!hasFailed()) {
setState(CALL_FAILED);
reporter_->failTest(failure);
}
}
void MockCheckedActualCall::copyOutputParameters(MockCheckedExpectedCall* expectedCall)
{
for (MockOutputParametersListNode* p = outputParameterExpectations_; p; p = p->next_)
{
MockNamedValue outputParameter = expectedCall->getOutputParameter(p->name_);
MockNamedValueCopier* copier = outputParameter.getCopier();
if (copier)
{
copier->copy(p->ptr_, outputParameter.getConstObjectPointer());
}
else if ((outputParameter.getType() == "const void*") && (p->type_ == "void*"))
{
const void* data = outputParameter.getConstPointerValue();
size_t size = outputParameter.getSize();
PlatformSpecificMemCpy(p->ptr_, data, size);
}
else if (outputParameter.getName() != "")
{
SimpleString type = expectedCall->getOutputParameter(p->name_).getType();
MockNoWayToCopyCustomTypeFailure failure(getTest(), type);
failTest(failure);
}
}
}
void MockCheckedActualCall::completeCallWhenMatchIsFound()
{
// Expectations that don't ignore parameters have higher fulfillment preference than those that ignore parameters
matchingExpectation_ = potentiallyMatchingExpectations_.removeFirstFinalizedMatchingExpectation();
if (matchingExpectation_) {
copyOutputParameters(matchingExpectation_);
callHasSucceeded();
} else {
MockCheckedExpectedCall* matchingExpectationWithIgnoredParameters = potentiallyMatchingExpectations_.getFirstMatchingExpectation();
if (matchingExpectationWithIgnoredParameters) {
copyOutputParameters(matchingExpectationWithIgnoredParameters);
}
}
}
void MockCheckedActualCall::callHasSucceeded()
{
setState(CALL_SUCCEED);
}
void MockCheckedActualCall::discardCurrentlyMatchingExpectations()
{
if (matchingExpectation_)
{
matchingExpectation_->resetActualCallMatchingState();
matchingExpectation_ = NULLPTR;
}
potentiallyMatchingExpectations_.onlyKeepUnmatchingExpectations();
}
MockActualCall& MockCheckedActualCall::withName(const SimpleString& name)
{
setName(name);
setState(CALL_IN_PROGRESS);
potentiallyMatchingExpectations_.onlyKeepExpectationsRelatedTo(name);
if (potentiallyMatchingExpectations_.isEmpty()) {
MockUnexpectedCallHappenedFailure failure(getTest(), name, allExpectations_);
failTest(failure);
return *this;
}
completeCallWhenMatchIsFound();
return *this;
}
MockActualCall& MockCheckedActualCall::withCallOrder(unsigned int)
{
return *this;
}
void MockCheckedActualCall::checkInputParameter(const MockNamedValue& actualParameter)
{
if(hasFailed())
{
return;
}
setState(CALL_IN_PROGRESS);
discardCurrentlyMatchingExpectations();
potentiallyMatchingExpectations_.onlyKeepExpectationsWithInputParameter(actualParameter);
if (potentiallyMatchingExpectations_.isEmpty()) {
MockUnexpectedInputParameterFailure failure(getTest(), getName(), actualParameter, allExpectations_);
failTest(failure);
return;
}
potentiallyMatchingExpectations_.parameterWasPassed(actualParameter.getName());
completeCallWhenMatchIsFound();
}
void MockCheckedActualCall::checkOutputParameter(const MockNamedValue& outputParameter)
{
if(hasFailed())
{
return;
}
setState(CALL_IN_PROGRESS);
discardCurrentlyMatchingExpectations();
potentiallyMatchingExpectations_.onlyKeepExpectationsWithOutputParameter(outputParameter);
if (potentiallyMatchingExpectations_.isEmpty()) {
MockUnexpectedOutputParameterFailure failure(getTest(), getName(), outputParameter, allExpectations_);
failTest(failure);
return;
}
potentiallyMatchingExpectations_.outputParameterWasPassed(outputParameter.getName());
completeCallWhenMatchIsFound();
}
MockActualCall& MockCheckedActualCall::withBoolParameter(const SimpleString& name, bool value)
{
MockNamedValue actualParameter(name);
actualParameter.setValue(value);
checkInputParameter(actualParameter);
return *this;
}
MockActualCall& MockCheckedActualCall::withUnsignedIntParameter(const SimpleString& name, unsigned int value)
{
MockNamedValue actualParameter(name);
actualParameter.setValue(value);
checkInputParameter(actualParameter);
return *this;
}
MockActualCall& MockCheckedActualCall::withIntParameter(const SimpleString& name, int value)
{
MockNamedValue actualParameter(name);
actualParameter.setValue(value);
checkInputParameter(actualParameter);
return *this;
}
MockActualCall& MockCheckedActualCall::withUnsignedLongIntParameter(const SimpleString& name, unsigned long int value)
{
MockNamedValue actualParameter(name);
actualParameter.setValue(value);
checkInputParameter(actualParameter);
return *this;
}
MockActualCall& MockCheckedActualCall::withLongIntParameter(const SimpleString& name, long int value)
{
MockNamedValue actualParameter(name);
actualParameter.setValue(value);
checkInputParameter(actualParameter);
return *this;
}
#if CPPUTEST_USE_LONG_LONG
MockActualCall& MockCheckedActualCall::withUnsignedLongLongIntParameter(const SimpleString& name, cpputest_ulonglong value)
{
MockNamedValue actualParameter(name);
actualParameter.setValue(value);
checkInputParameter(actualParameter);
return *this;
}
MockActualCall& MockCheckedActualCall::withLongLongIntParameter(const SimpleString& name, cpputest_longlong value)
{
MockNamedValue actualParameter(name);
actualParameter.setValue(value);
checkInputParameter(actualParameter);
return *this;
}
#else
MockActualCall& MockCheckedActualCall::withUnsignedLongLongIntParameter(const SimpleString&, cpputest_ulonglong)
{
FAIL("Unsigned Long Long type is not supported");
return *this;
}
MockActualCall& MockCheckedActualCall::withLongLongIntParameter(const SimpleString&, cpputest_longlong)
{
FAIL("Long Long type is not supported");
return *this;
}
#endif
MockActualCall& MockCheckedActualCall::withDoubleParameter(const SimpleString& name, double value)
{
MockNamedValue actualParameter(name);
actualParameter.setValue(value);
checkInputParameter(actualParameter);
return *this;
}
MockActualCall& MockCheckedActualCall::withStringParameter(const SimpleString& name, const char* value)
{
MockNamedValue actualParameter(name);
actualParameter.setValue(value);
checkInputParameter(actualParameter);
return *this;
}
MockActualCall& MockCheckedActualCall::withPointerParameter(const SimpleString& name, void* value)
{
MockNamedValue actualParameter(name);
actualParameter.setValue(value);
checkInputParameter(actualParameter);
return *this;
}
MockActualCall& MockCheckedActualCall::withConstPointerParameter(const SimpleString& name, const void* value)
{
MockNamedValue actualParameter(name);
actualParameter.setValue(value);
checkInputParameter(actualParameter);
return *this;
}
MockActualCall& MockCheckedActualCall::withFunctionPointerParameter(const SimpleString& name, void (*value)())
{
MockNamedValue actualParameter(name);
actualParameter.setValue(value);
checkInputParameter(actualParameter);
return *this;
}
MockActualCall& MockCheckedActualCall::withMemoryBufferParameter(const SimpleString& name, const unsigned char* value, size_t size)
{
MockNamedValue actualParameter(name);
actualParameter.setMemoryBuffer(value, size);
checkInputParameter(actualParameter);
return *this;
}
MockActualCall& MockCheckedActualCall::withParameterOfType(const SimpleString& type, const SimpleString& name, const void* value)
{
MockNamedValue actualParameter(name);
actualParameter.setConstObjectPointer(type, value);
if (actualParameter.getComparator() == NULLPTR) {
MockNoWayToCompareCustomTypeFailure failure(getTest(), type);
failTest(failure);
return *this;
}
checkInputParameter(actualParameter);
return *this;
}
MockActualCall& MockCheckedActualCall::withOutputParameter(const SimpleString& name, void* output)
{
addOutputParameter(name, "void*", output);
MockNamedValue outputParameter(name);
outputParameter.setValue(output);
checkOutputParameter(outputParameter);
return *this;
}
MockActualCall& MockCheckedActualCall::withOutputParameterOfType(const SimpleString& type, const SimpleString& name, void* output)
{
addOutputParameter(name, type, output);
MockNamedValue outputParameter(name);
outputParameter.setConstObjectPointer(type, output);
checkOutputParameter(outputParameter);
return *this;
}
bool MockCheckedActualCall::isFulfilled() const
{
return state_ == CALL_SUCCEED;
}
bool MockCheckedActualCall::hasFailed() const
{
return state_ == CALL_FAILED;
}
void MockCheckedActualCall::checkExpectations()
{
if(expectationsChecked_) {
return;
}
expectationsChecked_ = true;
if (state_ != CALL_IN_PROGRESS) {
if(state_ == CALL_SUCCEED) {
matchingExpectation_->callWasMade(callOrder_);
}
potentiallyMatchingExpectations_.resetActualCallMatchingState();
return;
}
if (potentiallyMatchingExpectations_.hasFinalizedMatchingExpectations())
FAIL("Actual call is in progress, but there are finalized matching expectations when checking expectations. This cannot happen."); // LCOV_EXCL_LINE
matchingExpectation_ = potentiallyMatchingExpectations_.removeFirstMatchingExpectation();
if (matchingExpectation_) {
matchingExpectation_->finalizeActualCallMatch();
callHasSucceeded();
matchingExpectation_->callWasMade(callOrder_);
potentiallyMatchingExpectations_.resetActualCallMatchingState();
return;
}
if (potentiallyMatchingExpectations_.hasUnmatchingExpectationsBecauseOfMissingParameters()) {
MockExpectedParameterDidntHappenFailure failure(getTest(), getName(), allExpectations_, potentiallyMatchingExpectations_);
failTest(failure);
}
else {
MockExpectedObjectDidntHappenFailure failure(getTest(), getName(), allExpectations_);
failTest(failure);
}
}
void MockCheckedActualCall::setState(ActualCallState state)
{
state_ = state;
}
MockNamedValue MockCheckedActualCall::returnValue()
{
checkExpectations();
if (matchingExpectation_)
return matchingExpectation_->returnValue();
return MockNamedValue("no return value");
}
bool MockCheckedActualCall::returnBoolValueOrDefault(bool default_value)
{
if (!hasReturnValue()) {
return default_value;
}
return returnBoolValue();
}
bool MockCheckedActualCall::returnBoolValue()
{
return returnValue().getBoolValue();
}
int MockCheckedActualCall::returnIntValueOrDefault(int default_value)
{
if (!hasReturnValue()) {
return default_value;
}
return returnIntValue();
}
int MockCheckedActualCall::returnIntValue()
{
return returnValue().getIntValue();
}
unsigned long int MockCheckedActualCall::returnUnsignedLongIntValue()
{
return returnValue().getUnsignedLongIntValue();
}
unsigned long int MockCheckedActualCall::returnUnsignedLongIntValueOrDefault(unsigned long int default_value)
{
if (!hasReturnValue()) {
return default_value;
}
return returnUnsignedLongIntValue();
}
long int MockCheckedActualCall::returnLongIntValue()
{
return returnValue().getLongIntValue();
}
long int MockCheckedActualCall::returnLongIntValueOrDefault(long int default_value)
{
if (!hasReturnValue()) {
return default_value;
}
return returnLongIntValue();
}
#if CPPUTEST_USE_LONG_LONG
cpputest_ulonglong MockCheckedActualCall::returnUnsignedLongLongIntValue()
{
return returnValue().getUnsignedLongLongIntValue();
}
cpputest_ulonglong MockCheckedActualCall::returnUnsignedLongLongIntValueOrDefault(cpputest_ulonglong default_value)
{
if (!hasReturnValue()) {
return default_value;
}
return returnUnsignedLongLongIntValue();
}
cpputest_longlong MockCheckedActualCall::returnLongLongIntValue()
{
return returnValue().getLongLongIntValue();
}
cpputest_longlong MockCheckedActualCall::returnLongLongIntValueOrDefault(cpputest_longlong default_value)
{
if (!hasReturnValue()) {
return default_value;
}
return returnLongLongIntValue();
}
#else
cpputest_ulonglong MockCheckedActualCall::returnUnsignedLongLongIntValue()
{
FAIL("Unsigned Long Long type is not supported");
cpputest_ulonglong ret = {};
return ret;
}
cpputest_ulonglong MockCheckedActualCall::returnUnsignedLongLongIntValueOrDefault(cpputest_ulonglong default_value)
{
FAIL("Unsigned Long Long type is not supported");
return default_value;
}
cpputest_longlong MockCheckedActualCall::returnLongLongIntValue()
{
FAIL("Long Long type is not supported");
cpputest_longlong ret = {};
return ret;
}
cpputest_longlong MockCheckedActualCall::returnLongLongIntValueOrDefault(cpputest_longlong default_value)
{
FAIL("Long Long type is not supported");
return default_value;
}
#endif
double MockCheckedActualCall::returnDoubleValue()
{
return returnValue().getDoubleValue();
}
double MockCheckedActualCall::returnDoubleValueOrDefault(double default_value)
{
if (!hasReturnValue()) {
return default_value;
}
return returnDoubleValue();
}
unsigned int MockCheckedActualCall::returnUnsignedIntValue()
{
return returnValue().getUnsignedIntValue();
}
unsigned int MockCheckedActualCall::returnUnsignedIntValueOrDefault(unsigned int default_value)
{
if (!hasReturnValue()) {
return default_value;
}
return returnUnsignedIntValue();
}
void * MockCheckedActualCall::returnPointerValueOrDefault(void * default_value)
{
if (!hasReturnValue()) {
return default_value;
}
return returnPointerValue();
}
void * MockCheckedActualCall::returnPointerValue()
{
return returnValue().getPointerValue();
}
const void * MockCheckedActualCall::returnConstPointerValue()
{
return returnValue().getConstPointerValue();
}
const void * MockCheckedActualCall::returnConstPointerValueOrDefault(const void * default_value)
{
if (!hasReturnValue()) {
return default_value;
}
return returnConstPointerValue();
}
void (*MockCheckedActualCall::returnFunctionPointerValue())()
{
return returnValue().getFunctionPointerValue();
}
void (*MockCheckedActualCall::returnFunctionPointerValueOrDefault(void (*default_value)()))()
{
if (!hasReturnValue()) {
return default_value;
}
return returnFunctionPointerValue();
}
const char * MockCheckedActualCall::returnStringValueOrDefault(const char * default_value)
{
if (!hasReturnValue()) {
return default_value;
}
return returnStringValue();
}
const char * MockCheckedActualCall::returnStringValue()
{
return returnValue().getStringValue();
}
bool MockCheckedActualCall::hasReturnValue()
{
return ! returnValue().getName().isEmpty();
}
MockActualCall& MockCheckedActualCall::onObject(const void* objectPtr)
{
if(hasFailed()) {
return *this;
}
// Currently matching expectations are not discarded because the passed object
// is ignored if not specifically set in the expectation
potentiallyMatchingExpectations_.onlyKeepExpectationsOnObject(objectPtr);
if ((!matchingExpectation_) && potentiallyMatchingExpectations_.isEmpty()) {
MockUnexpectedObjectFailure failure(getTest(), getName(), objectPtr, allExpectations_);
failTest(failure);
return *this;
}
potentiallyMatchingExpectations_.wasPassedToObject();
if (!matchingExpectation_) {
completeCallWhenMatchIsFound();
}
return *this;
}
void MockCheckedActualCall::addOutputParameter(const SimpleString& name, const SimpleString& type, void* ptr)
{
MockOutputParametersListNode* newNode = new MockOutputParametersListNode(name, type, ptr);
if (outputParameterExpectations_ == NULLPTR)
outputParameterExpectations_ = newNode;
else {
MockOutputParametersListNode* lastNode = outputParameterExpectations_;
while (lastNode->next_) lastNode = lastNode->next_;
lastNode->next_ = newNode;
}
}
void MockCheckedActualCall::cleanUpOutputParameterList()
{
MockOutputParametersListNode* current = outputParameterExpectations_;
MockOutputParametersListNode* toBeDeleted = NULLPTR;
while (current) {
toBeDeleted = current;
outputParameterExpectations_ = current = current->next_;
delete toBeDeleted;
}
}
MockActualCallTrace::MockActualCallTrace()
{
}
MockActualCallTrace::~MockActualCallTrace()
{
}
MockActualCall& MockActualCallTrace::withName(const SimpleString& name)
{
traceBuffer_ += "\nFunction name:";
traceBuffer_ += name;
return *this;
}
MockActualCall& MockActualCallTrace::withCallOrder(unsigned int callOrder)
{
traceBuffer_ += " withCallOrder:";
traceBuffer_ += StringFrom(callOrder);
return *this;
}
void MockActualCallTrace::addParameterName(const SimpleString& name)
{
traceBuffer_ += " ";
traceBuffer_ += name;
traceBuffer_ += ":";
}
MockActualCall& MockActualCallTrace::withBoolParameter(const SimpleString& name, bool value)
{
addParameterName(name);
traceBuffer_ += StringFrom(value);
return *this;
}
MockActualCall& MockActualCallTrace::withUnsignedIntParameter(const SimpleString& name, unsigned int value)
{
addParameterName(name);
traceBuffer_ += StringFrom(value) + " " + BracketsFormattedHexStringFrom(value);
return *this;
}
MockActualCall& MockActualCallTrace::withIntParameter(const SimpleString& name, int value)
{
addParameterName(name);
traceBuffer_ += StringFrom(value) + " " + BracketsFormattedHexStringFrom(value);
return *this;
}
MockActualCall& MockActualCallTrace::withUnsignedLongIntParameter(const SimpleString& name, unsigned long int value)
{
addParameterName(name);
traceBuffer_ += StringFrom(value) + " " + BracketsFormattedHexStringFrom(value);
return *this;
}
MockActualCall& MockActualCallTrace::withLongIntParameter(const SimpleString& name, long int value)
{
addParameterName(name);
traceBuffer_ += StringFrom(value) + " " + BracketsFormattedHexStringFrom(value);
return *this;
}
#if CPPUTEST_USE_LONG_LONG
MockActualCall& MockActualCallTrace::withUnsignedLongLongIntParameter(const SimpleString& name, cpputest_ulonglong value)
{
addParameterName(name);
traceBuffer_ += StringFrom(value) + " " + BracketsFormattedHexStringFrom(value);
return *this;
}
MockActualCall& MockActualCallTrace::withLongLongIntParameter(const SimpleString& name, cpputest_longlong value)
{
addParameterName(name);
traceBuffer_ += StringFrom(value) + " " + BracketsFormattedHexStringFrom(value);
return *this;
}
#else
MockActualCall& MockActualCallTrace::withUnsignedLongLongIntParameter(const SimpleString&, cpputest_ulonglong)
{
FAIL("Unsigned Long Long type is not supported");
return *this;
}
MockActualCall& MockActualCallTrace::withLongLongIntParameter(const SimpleString&, cpputest_longlong)
{
FAIL("Long Long type is not supported");
return *this;
}
#endif
MockActualCall& MockActualCallTrace::withDoubleParameter(const SimpleString& name, double value)
{
addParameterName(name);
traceBuffer_ += StringFrom(value);
return *this;
}
MockActualCall& MockActualCallTrace::withStringParameter(const SimpleString& name, const char* value)
{
addParameterName(name);
traceBuffer_ += StringFrom(value);
return *this;
}
MockActualCall& MockActualCallTrace::withPointerParameter(const SimpleString& name, void* value)
{
addParameterName(name);
traceBuffer_ += StringFrom(value);
return *this;
}
MockActualCall& MockActualCallTrace::withConstPointerParameter(const SimpleString& name, const void* value)
{
addParameterName(name);
traceBuffer_ += StringFrom(value);
return *this;
}
MockActualCall& MockActualCallTrace::withFunctionPointerParameter(const SimpleString& name, void (*value)())
{
addParameterName(name);
traceBuffer_ += StringFrom(value);
return *this;
}
MockActualCall& MockActualCallTrace::withMemoryBufferParameter(const SimpleString& name, const unsigned char* value, size_t size)
{
addParameterName(name);
traceBuffer_ += StringFromBinaryWithSizeOrNull(value, size);
return *this;
}
MockActualCall& MockActualCallTrace::withParameterOfType(const SimpleString& typeName, const SimpleString& name, const void* value)
{
traceBuffer_ += " ";
traceBuffer_ += typeName;
addParameterName(name);
traceBuffer_ += StringFrom(value);
return *this;
}
MockActualCall& MockActualCallTrace::withOutputParameter(const SimpleString& name, void* output)
{
addParameterName(name);
traceBuffer_ += StringFrom(output);
return *this;
}
MockActualCall& MockActualCallTrace::withOutputParameterOfType(const SimpleString& typeName, const SimpleString& name, void* output)
{
traceBuffer_ += " ";
traceBuffer_ += typeName;
addParameterName(name);
traceBuffer_ += StringFrom(output);
return *this;
}
bool MockActualCallTrace::hasReturnValue()
{
return false;
}
MockNamedValue MockActualCallTrace::returnValue()
{
return MockNamedValue("");
}
long int MockActualCallTrace::returnLongIntValue()
{
return 0;
}
unsigned long int MockActualCallTrace::returnUnsignedLongIntValue()
{
return 0;
}
unsigned long int MockActualCallTrace::returnUnsignedLongIntValueOrDefault(unsigned long)
{
return 0;
}
long int MockActualCallTrace::returnLongIntValueOrDefault(long int)
{
return 0;
}
#if CPPUTEST_USE_LONG_LONG
cpputest_longlong MockActualCallTrace::returnLongLongIntValue()
{
return 0;
}
cpputest_ulonglong MockActualCallTrace::returnUnsignedLongLongIntValue()
{
return 0;
}
cpputest_ulonglong MockActualCallTrace::returnUnsignedLongLongIntValueOrDefault(cpputest_ulonglong)
{
return 0;
}
cpputest_longlong MockActualCallTrace::returnLongLongIntValueOrDefault(cpputest_longlong)
{
return 0;
}
#else
cpputest_longlong MockActualCallTrace::returnLongLongIntValue()
{
FAIL("Long Long type is not supported");
cpputest_longlong ret = {};
return ret;
}
cpputest_ulonglong MockActualCallTrace::returnUnsignedLongLongIntValue()
{
FAIL("Unsigned Long Long type is not supported");
cpputest_ulonglong ret = {};
return ret;
}
cpputest_ulonglong MockActualCallTrace::returnUnsignedLongLongIntValueOrDefault(cpputest_ulonglong)
{
FAIL("Unsigned Long Long type is not supported");
cpputest_ulonglong ret = {};
return ret;
}
cpputest_longlong MockActualCallTrace::returnLongLongIntValueOrDefault(cpputest_longlong)
{
FAIL("Long Long type is not supported");
cpputest_longlong ret = {};
return ret;
}
#endif
bool MockActualCallTrace::returnBoolValue()
{
return false;
}
bool MockActualCallTrace::returnBoolValueOrDefault(bool)
{
return false;
}
int MockActualCallTrace::returnIntValue()
{
return 0;
}
double MockActualCallTrace::returnDoubleValue()
{
return 0.0;
}
double MockActualCallTrace::returnDoubleValueOrDefault(double)
{
return returnDoubleValue();
}
unsigned int MockActualCallTrace::returnUnsignedIntValue()
{
return 0;
}
void * MockActualCallTrace::returnPointerValue()
{
return NULLPTR;
}
const void * MockActualCallTrace::returnConstPointerValue()
{
return NULLPTR;
}
void (*MockActualCallTrace::returnFunctionPointerValue())()
{
return NULLPTR;
}
const void * MockActualCallTrace::returnConstPointerValueOrDefault(const void *)
{
return returnConstPointerValue();
}
void * MockActualCallTrace::returnPointerValueOrDefault(void *)
{
return returnPointerValue();
}
void (*MockActualCallTrace::returnFunctionPointerValueOrDefault(void (*)()))()
{
return returnFunctionPointerValue();
}
const char * MockActualCallTrace::returnStringValue()
{
return "";
}
const char * MockActualCallTrace::returnStringValueOrDefault(const char *)
{
return returnStringValue();
}
int MockActualCallTrace::returnIntValueOrDefault(int)
{
return 0;
}
unsigned int MockActualCallTrace::returnUnsignedIntValueOrDefault(unsigned int)
{
return returnUnsignedIntValue();
}
MockActualCall& MockActualCallTrace::onObject(const void* objectPtr)
{
traceBuffer_ += " onObject:";
traceBuffer_ += StringFrom(objectPtr);
return *this;
}
void MockActualCallTrace::clear()
{
traceBuffer_ = "";
}
const char* MockActualCallTrace::getTraceOutput()
{
return traceBuffer_.asCharString();
}
MockActualCallTrace* MockActualCallTrace::instance_ = NULLPTR;
MockActualCallTrace& MockActualCallTrace::instance()
{
if (instance_ == NULLPTR)
instance_ = new MockActualCallTrace;
return *instance_;
}
void MockActualCallTrace::clearInstance()
{
delete instance_;
instance_ = NULLPTR;
}
MockIgnoredActualCall& MockIgnoredActualCall::instance()
{
static MockIgnoredActualCall call;
return call;
}
| null |
35 | cpp | cpputest | MockSupport_c.cpp | src/CppUTestExt/MockSupport_c.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/CppUTestConfig.h"
#include "CppUTest/Utest.h"
#include "CppUTest/UtestMacros.h"
#include "CppUTest/PlatformSpecificFunctions_c.h"
#include "CppUTestExt/MockSupport.h"
#include "CppUTestExt/MockSupport_c.h"
typedef void (*cpputest_cpp_function_pointer)(); /* Cl2000 requires cast to C++ function */
class MockFailureReporterTestTerminatorForInCOnlyCode : public TestTerminator
{
public:
MockFailureReporterTestTerminatorForInCOnlyCode(bool crashOnFailure) : crashOnFailure_(crashOnFailure)
{
}
virtual void exitCurrentTest() const CPPUTEST_OVERRIDE
{
if (crashOnFailure_)
UT_CRASH();
UtestShell::getCurrentTestTerminatorWithoutExceptions().exitCurrentTest();
} // LCOV_EXCL_LINE
// LCOV_EXCL_START
virtual ~MockFailureReporterTestTerminatorForInCOnlyCode() CPPUTEST_DESTRUCTOR_OVERRIDE
{
}
// LCOV_EXCL_STOP
private:
bool crashOnFailure_;
};
class MockFailureReporterForInCOnlyCode : public MockFailureReporter
{
public:
void failTest(const MockFailure& failure) CPPUTEST_OVERRIDE
{
if (!getTestToFail()->hasFailed())
getTestToFail()->failWith(failure, MockFailureReporterTestTerminatorForInCOnlyCode(crashOnFailure_));
} // LCOV_EXCL_LINE
};
static MockSupport* currentMockSupport = NULLPTR;
static MockExpectedCall* expectedCall = NULLPTR;
static MockActualCall* actualCall = NULLPTR;
static MockFailureReporterForInCOnlyCode failureReporterForC;
class MockCFunctionComparatorNode : public MockNamedValueComparator
{
public:
MockCFunctionComparatorNode(MockCFunctionComparatorNode* next, MockTypeEqualFunction_c equal, MockTypeValueToStringFunction_c toString)
: next_(next), equal_(equal), toString_(toString) {}
virtual ~MockCFunctionComparatorNode() CPPUTEST_DESTRUCTOR_OVERRIDE {}
virtual bool isEqual(const void* object1, const void* object2) CPPUTEST_OVERRIDE
{
return equal_(object1, object2) != 0;
}
virtual SimpleString valueToString(const void* object) CPPUTEST_OVERRIDE
{
return SimpleString(toString_(object));
}
MockCFunctionComparatorNode* next_;
MockTypeEqualFunction_c equal_;
MockTypeValueToStringFunction_c toString_;
};
static MockCFunctionComparatorNode* comparatorList_ = NULLPTR;
class MockCFunctionCopierNode : public MockNamedValueCopier
{
public:
MockCFunctionCopierNode(MockCFunctionCopierNode* next, MockTypeCopyFunction_c copier)
: next_(next), copier_(copier) {}
virtual ~MockCFunctionCopierNode() CPPUTEST_DESTRUCTOR_OVERRIDE {}
virtual void copy(void* dst, const void* src) CPPUTEST_OVERRIDE
{
copier_(dst, src);
}
MockCFunctionCopierNode* next_;
MockTypeCopyFunction_c copier_;
};
static MockCFunctionCopierNode* copierList_ = NULLPTR;
extern "C" {
void strictOrder_c();
MockExpectedCall_c* expectOneCall_c(const char* name);
void expectNoCall_c(const char* name);
MockExpectedCall_c* expectNCalls_c(const unsigned int number, const char* name);
MockActualCall_c* actualCall_c(const char* name);
void disable_c();
void enable_c();
void ignoreOtherCalls_c();
void setBoolData_c(const char* name, int value);
void setIntData_c(const char* name, int value);
void setUnsignedIntData_c(const char* name, unsigned int value);
void setDoubleData_c(const char* name, double value);
void setStringData_c(const char* name, const char* value);
void setPointerData_c(const char* name, void* value);
void setConstPointerData_c(const char* name, const void* value);
void setFunctionPointerData_c(const char* name, void (*value)());
void setDataObject_c(const char* name, const char* type, void* value);
void setDataConstObject_c(const char* name, const char* type, const void* value);
MockValue_c getData_c(const char* name);
int hasReturnValue_c();
void checkExpectations_c();
int expectedCallsLeft_c();
void clear_c();
void crashOnFailure_c(unsigned shouldCrash);
MockExpectedCall_c* withBoolParameters_c(const char* name, int value);
MockExpectedCall_c* withIntParameters_c(const char* name, int value);
MockExpectedCall_c* withUnsignedIntParameters_c(const char* name, unsigned int value);
MockExpectedCall_c* withLongIntParameters_c(const char* name, long int value);
MockExpectedCall_c* withUnsignedLongIntParameters_c(const char* name, unsigned long int value);
MockExpectedCall_c* withLongLongIntParameters_c(const char* name, cpputest_longlong value);
MockExpectedCall_c* withUnsignedLongLongIntParameters_c(const char* name, cpputest_ulonglong value);
MockExpectedCall_c* withDoubleParameters_c(const char* name, double value);
MockExpectedCall_c* withDoubleParametersAndTolerance_c(const char* name, double value, double tolerance);
MockExpectedCall_c* withStringParameters_c(const char* name, const char* value);
MockExpectedCall_c* withPointerParameters_c(const char* name, void* value);
MockExpectedCall_c* withConstPointerParameters_c(const char* name, const void* value);
MockExpectedCall_c* withFunctionPointerParameters_c(const char* name, void (*value)());
MockExpectedCall_c* withMemoryBufferParameters_c(const char* name, const unsigned char* value, size_t size);
MockExpectedCall_c* withParameterOfType_c(const char* type, const char* name, const void* value);
MockExpectedCall_c* withOutputParameterReturning_c(const char* name, const void* value, size_t size);
MockExpectedCall_c* withOutputParameterOfTypeReturning_c(const char* type, const char* name, const void* value);
MockExpectedCall_c* withUnmodifiedOutputParameter_c(const char* name);
MockExpectedCall_c* ignoreOtherParameters_c();
MockExpectedCall_c* andReturnBoolValue_c(int value);
MockExpectedCall_c* andReturnIntValue_c(int value);
MockExpectedCall_c* andReturnUnsignedIntValue_c(unsigned int value);
MockExpectedCall_c* andReturnLongIntValue_c(long int value);
MockExpectedCall_c* andReturnUnsignedLongIntValue_c(unsigned long int value);
MockExpectedCall_c* andReturnLongLongIntValue_c(cpputest_longlong value);
MockExpectedCall_c* andReturnUnsignedLongLongIntValue_c(cpputest_ulonglong value);
MockExpectedCall_c* andReturnDoubleValue_c(double value);
MockExpectedCall_c* andReturnStringValue_c(const char* value);
MockExpectedCall_c* andReturnPointerValue_c(void* value);
MockExpectedCall_c* andReturnConstPointerValue_c(const void* value);
MockExpectedCall_c* andReturnFunctionPointerValue_c(void (*value)());
MockActualCall_c* withActualBoolParameters_c(const char* name, int value);
MockActualCall_c* withActualIntParameters_c(const char* name, int value);
MockActualCall_c* withActualUnsignedIntParameters_c(const char* name, unsigned int value);
MockActualCall_c* withActualLongIntParameters_c(const char* name, long int value);
MockActualCall_c* withActualUnsignedLongIntParameters_c(const char* name, unsigned long int value);
MockActualCall_c* withActualLongLongIntParameters_c(const char* name, cpputest_longlong value);
MockActualCall_c* withActualUnsignedLongLongIntParameters_c(const char* name, cpputest_ulonglong value);
MockActualCall_c* withActualDoubleParameters_c(const char* name, double value);
MockActualCall_c* withActualStringParameters_c(const char* name, const char* value);
MockActualCall_c* withActualPointerParameters_c(const char* name, void* value);
MockActualCall_c* withActualConstPointerParameters_c(const char* name, const void* value);
MockActualCall_c* withActualFunctionPointerParameters_c(const char* name, void (*value)());
MockActualCall_c* withActualMemoryBufferParameters_c(const char* name, const unsigned char* value, size_t size);
MockActualCall_c* withActualParameterOfType_c(const char* type, const char* name, const void* value);
MockActualCall_c* withActualOutputParameter_c(const char* name, void* value);
MockActualCall_c* withActualOutputParameterOfType_c(const char* type, const char* name, void* value);
MockValue_c returnValue_c();
int boolReturnValue_c();
int returnBoolValueOrDefault_c(int defaultValue);
int intReturnValue_c();
int returnIntValueOrDefault_c(int defaultValue);
unsigned int unsignedIntReturnValue_c();
unsigned int returnUnsignedIntValueOrDefault_c(unsigned int defaultValue);
long int longIntReturnValue_c();
long int returnLongIntValueOrDefault_c(long int defaultValue);
unsigned long int unsignedLongIntReturnValue_c();
unsigned long int returnUnsignedLongIntValueOrDefault_c(unsigned long int defaultValue);
cpputest_longlong longLongIntReturnValue_c();
cpputest_longlong returnLongLongIntValueOrDefault_c(cpputest_longlong defaultValue);
cpputest_ulonglong unsignedLongLongIntReturnValue_c();
cpputest_ulonglong returnUnsignedLongLongIntValueOrDefault_c(cpputest_ulonglong defaultValue);
const char* stringReturnValue_c();
const char* returnStringValueOrDefault_c(const char * defaultValue);
double doubleReturnValue_c();
double returnDoubleValueOrDefault_c(double defaultValue);
void* pointerReturnValue_c();
void* returnPointerValueOrDefault_c(void * defaultValue);
const void* constPointerReturnValue_c();
const void* returnConstPointerValueOrDefault_c(const void * defaultValue);
void (*functionPointerReturnValue_c())();
void (*returnFunctionPointerValueOrDefault_c(void(*defaultValue)()))();
static void installComparator_c (const char* typeName, MockTypeEqualFunction_c isEqual, MockTypeValueToStringFunction_c valueToString)
{
comparatorList_ = new MockCFunctionComparatorNode(comparatorList_, isEqual, valueToString);
currentMockSupport->installComparator(typeName, *comparatorList_);
}
static void installCopier_c (const char* typeName, MockTypeCopyFunction_c copier)
{
copierList_ = new MockCFunctionCopierNode(copierList_, copier);
currentMockSupport->installCopier(typeName, *copierList_);
}
static void removeAllComparatorsAndCopiers_c()
{
while (comparatorList_) {
MockCFunctionComparatorNode *next = comparatorList_->next_;
delete comparatorList_;
comparatorList_ = next;
}
while (copierList_) {
MockCFunctionCopierNode *next = copierList_->next_;
delete copierList_;
copierList_ = next;
}
currentMockSupport->removeAllComparatorsAndCopiers();
}
static MockExpectedCall_c gExpectedCall = {
withBoolParameters_c,
withIntParameters_c,
withUnsignedIntParameters_c,
withLongIntParameters_c,
withUnsignedLongIntParameters_c,
withLongLongIntParameters_c,
withUnsignedLongLongIntParameters_c,
withDoubleParameters_c,
withDoubleParametersAndTolerance_c,
withStringParameters_c,
withPointerParameters_c,
withConstPointerParameters_c,
withFunctionPointerParameters_c,
withMemoryBufferParameters_c,
withParameterOfType_c,
withOutputParameterReturning_c,
withOutputParameterOfTypeReturning_c,
withUnmodifiedOutputParameter_c,
ignoreOtherParameters_c,
andReturnBoolValue_c,
andReturnUnsignedIntValue_c,
andReturnIntValue_c,
andReturnLongIntValue_c,
andReturnUnsignedLongIntValue_c,
andReturnLongLongIntValue_c,
andReturnUnsignedLongLongIntValue_c,
andReturnDoubleValue_c,
andReturnStringValue_c,
andReturnPointerValue_c,
andReturnConstPointerValue_c,
andReturnFunctionPointerValue_c,
};
static MockActualCall_c gActualCall = {
withActualBoolParameters_c,
withActualIntParameters_c,
withActualUnsignedIntParameters_c,
withActualLongIntParameters_c,
withActualUnsignedLongIntParameters_c,
withActualLongLongIntParameters_c,
withActualUnsignedLongLongIntParameters_c,
withActualDoubleParameters_c,
withActualStringParameters_c,
withActualPointerParameters_c,
withActualConstPointerParameters_c,
withActualFunctionPointerParameters_c,
withActualMemoryBufferParameters_c,
withActualParameterOfType_c,
withActualOutputParameter_c,
withActualOutputParameterOfType_c,
hasReturnValue_c,
returnValue_c,
boolReturnValue_c,
returnBoolValueOrDefault_c,
intReturnValue_c,
returnIntValueOrDefault_c,
unsignedIntReturnValue_c,
returnUnsignedIntValueOrDefault_c,
longIntReturnValue_c,
returnLongIntValueOrDefault_c,
unsignedLongIntReturnValue_c,
returnUnsignedLongIntValueOrDefault_c,
longLongIntReturnValue_c,
returnLongLongIntValueOrDefault_c,
unsignedLongLongIntReturnValue_c,
returnUnsignedLongLongIntValueOrDefault_c,
stringReturnValue_c,
returnStringValueOrDefault_c,
doubleReturnValue_c,
returnDoubleValueOrDefault_c,
pointerReturnValue_c,
returnPointerValueOrDefault_c,
constPointerReturnValue_c,
returnConstPointerValueOrDefault_c,
functionPointerReturnValue_c,
returnFunctionPointerValueOrDefault_c
};
static MockSupport_c gMockSupport = {
strictOrder_c,
expectOneCall_c,
expectNoCall_c,
expectNCalls_c,
actualCall_c,
hasReturnValue_c,
returnValue_c,
boolReturnValue_c,
returnBoolValueOrDefault_c,
intReturnValue_c,
returnIntValueOrDefault_c,
unsignedIntReturnValue_c,
returnUnsignedIntValueOrDefault_c,
longIntReturnValue_c,
returnLongIntValueOrDefault_c,
unsignedLongIntReturnValue_c,
returnUnsignedLongIntValueOrDefault_c,
longLongIntReturnValue_c,
returnLongLongIntValueOrDefault_c,
unsignedLongLongIntReturnValue_c,
returnUnsignedLongLongIntValueOrDefault_c,
stringReturnValue_c,
returnStringValueOrDefault_c,
doubleReturnValue_c,
returnDoubleValueOrDefault_c,
pointerReturnValue_c,
returnPointerValueOrDefault_c,
constPointerReturnValue_c,
returnConstPointerValueOrDefault_c,
functionPointerReturnValue_c,
returnFunctionPointerValueOrDefault_c,
setBoolData_c,
setIntData_c,
setUnsignedIntData_c,
setStringData_c,
setDoubleData_c,
setPointerData_c,
setConstPointerData_c,
setFunctionPointerData_c,
setDataObject_c,
setDataConstObject_c,
getData_c,
disable_c,
enable_c,
ignoreOtherCalls_c,
checkExpectations_c,
expectedCallsLeft_c,
clear_c,
crashOnFailure_c,
installComparator_c,
installCopier_c,
removeAllComparatorsAndCopiers_c
};
MockExpectedCall_c* withBoolParameters_c(const char* name, int value)
{
expectedCall = &expectedCall->withParameter(name, (value != 0));
return &gExpectedCall;
}
MockExpectedCall_c* withIntParameters_c(const char* name, int value)
{
expectedCall = &expectedCall->withParameter(name, value);
return &gExpectedCall;
}
MockExpectedCall_c* withUnsignedIntParameters_c(const char* name, unsigned int value)
{
expectedCall = &expectedCall->withParameter(name, value);
return &gExpectedCall;
}
MockExpectedCall_c* withLongIntParameters_c(const char* name, long int value)
{
expectedCall = &expectedCall->withParameter(name, value);
return &gExpectedCall;
}
MockExpectedCall_c* withUnsignedLongIntParameters_c(const char* name, unsigned long int value)
{
expectedCall = &expectedCall->withParameter(name, value);
return &gExpectedCall;
}
#if CPPUTEST_USE_LONG_LONG
MockExpectedCall_c* withLongLongIntParameters_c(const char* name, cpputest_longlong value)
{
expectedCall = &expectedCall->withParameter(name, value);
return &gExpectedCall;
}
MockExpectedCall_c* withUnsignedLongLongIntParameters_c(const char* name, cpputest_ulonglong value)
{
expectedCall = &expectedCall->withParameter(name, value);
return &gExpectedCall;
}
#else
MockExpectedCall_c* withLongLongIntParameters_c(const char*, cpputest_longlong)
{
FAIL("Long Long type is not supported");
return &gExpectedCall;
}
MockExpectedCall_c* withUnsignedLongLongIntParameters_c(const char*, cpputest_ulonglong)
{
FAIL("Unsigned Long Long type is not supported");
return &gExpectedCall;
}
#endif
MockExpectedCall_c* withDoubleParameters_c(const char* name, double value)
{
expectedCall = &expectedCall->withParameter(name, value);
return &gExpectedCall;
}
MockExpectedCall_c* withDoubleParametersAndTolerance_c(const char* name, double value, double tolerance)
{
expectedCall = &expectedCall->withParameter(name, value, tolerance);
return &gExpectedCall;
}
MockExpectedCall_c* withStringParameters_c(const char* name, const char* value)
{
expectedCall = &expectedCall->withParameter(name, value);
return &gExpectedCall;
}
MockExpectedCall_c* withPointerParameters_c(const char* name, void* value)
{
expectedCall = &expectedCall->withParameter(name, value);
return &gExpectedCall;
}
MockExpectedCall_c* withConstPointerParameters_c(const char* name, const void* value)
{
expectedCall = &expectedCall->withParameter(name, value);
return &gExpectedCall;
}
MockExpectedCall_c* withFunctionPointerParameters_c(const char* name, void (*value)())
{
expectedCall = &expectedCall->withParameter(name, (cpputest_cpp_function_pointer)value);
return &gExpectedCall;
}
MockExpectedCall_c* withMemoryBufferParameters_c(const char* name, const unsigned char* value, size_t size)
{
expectedCall = &expectedCall->withParameter(name, value, size);
return &gExpectedCall;
}
MockExpectedCall_c* withParameterOfType_c(const char* type, const char* name, const void* value)
{
expectedCall = &expectedCall->withParameterOfType(type, name, value);
return &gExpectedCall;
}
MockExpectedCall_c* withOutputParameterReturning_c(const char* name, const void* value, size_t size)
{
expectedCall = &expectedCall->withOutputParameterReturning(name, value, size);
return &gExpectedCall;
}
MockExpectedCall_c* withOutputParameterOfTypeReturning_c(const char* type, const char* name, const void* value)
{
expectedCall = &expectedCall->withOutputParameterOfTypeReturning(type, name, value);
return &gExpectedCall;
}
MockExpectedCall_c* withUnmodifiedOutputParameter_c(const char* name)
{
expectedCall = &expectedCall->withUnmodifiedOutputParameter(name);
return &gExpectedCall;
}
MockExpectedCall_c* ignoreOtherParameters_c()
{
expectedCall = &expectedCall->ignoreOtherParameters();
return &gExpectedCall;
}
MockExpectedCall_c* andReturnBoolValue_c(int value)
{
expectedCall = &expectedCall->andReturnValue(value != 0);
return &gExpectedCall;
}
MockExpectedCall_c* andReturnUnsignedIntValue_c(unsigned int value)
{
expectedCall = &expectedCall->andReturnValue(value);
return &gExpectedCall;
}
MockExpectedCall_c* andReturnIntValue_c(int value)
{
expectedCall = &expectedCall->andReturnValue(value);
return &gExpectedCall;
}
MockExpectedCall_c* andReturnLongIntValue_c(long int value)
{
expectedCall = &expectedCall->andReturnValue(value);
return &gExpectedCall;
}
MockExpectedCall_c* andReturnUnsignedLongIntValue_c(unsigned long int value)
{
expectedCall = &expectedCall->andReturnValue(value);
return &gExpectedCall;
}
#if CPPUTEST_USE_LONG_LONG
MockExpectedCall_c* andReturnLongLongIntValue_c(cpputest_longlong value)
{
expectedCall = &expectedCall->andReturnValue(value);
return &gExpectedCall;
}
MockExpectedCall_c* andReturnUnsignedLongLongIntValue_c(cpputest_ulonglong value)
{
expectedCall = &expectedCall->andReturnValue(value);
return &gExpectedCall;
}
#else
MockExpectedCall_c* andReturnLongLongIntValue_c(cpputest_longlong)
{
FAIL("Long Long type is not supported");
return &gExpectedCall;
}
MockExpectedCall_c* andReturnUnsignedLongLongIntValue_c(cpputest_ulonglong)
{
FAIL("Unsigned Long Long type is not supported");
return &gExpectedCall;
}
#endif
MockExpectedCall_c* andReturnDoubleValue_c(double value)
{
expectedCall = &expectedCall->andReturnValue(value);
return &gExpectedCall;
}
MockExpectedCall_c* andReturnStringValue_c(const char* value)
{
expectedCall = &expectedCall->andReturnValue(value);
return &gExpectedCall;
}
MockExpectedCall_c* andReturnPointerValue_c(void* value)
{
expectedCall = &expectedCall->andReturnValue(value);
return &gExpectedCall;
}
MockExpectedCall_c* andReturnConstPointerValue_c(const void* value)
{
expectedCall = &expectedCall->andReturnValue(value);
return &gExpectedCall;
}
MockExpectedCall_c* andReturnFunctionPointerValue_c(void (*value)())
{
expectedCall = &expectedCall->andReturnValue((cpputest_cpp_function_pointer)value);
return &gExpectedCall;
}
static MockValue_c getMockValueCFromNamedValue(const MockNamedValue& namedValue)
{
MockValue_c returnValue;
if (SimpleString::StrCmp(namedValue.getType().asCharString(), "bool") == 0) {
returnValue.type = MOCKVALUETYPE_BOOL;
returnValue.value.boolValue = namedValue.getBoolValue() ? 1 : 0;
}
else if (SimpleString::StrCmp(namedValue.getType().asCharString(), "int") == 0) {
returnValue.type = MOCKVALUETYPE_INTEGER;
returnValue.value.intValue = namedValue.getIntValue();
}
else if (SimpleString::StrCmp(namedValue.getType().asCharString(), "unsigned int") == 0) {
returnValue.type = MOCKVALUETYPE_UNSIGNED_INTEGER;
returnValue.value.unsignedIntValue = namedValue.getUnsignedIntValue();
}
else if (SimpleString::StrCmp(namedValue.getType().asCharString(), "long int") == 0) {
returnValue.type = MOCKVALUETYPE_LONG_INTEGER;
returnValue.value.longIntValue = namedValue.getLongIntValue();
}
else if (SimpleString::StrCmp(namedValue.getType().asCharString(), "unsigned long int") == 0) {
returnValue.type = MOCKVALUETYPE_UNSIGNED_LONG_INTEGER;
returnValue.value.unsignedLongIntValue = namedValue.getUnsignedLongIntValue();
}
#if CPPUTEST_USE_LONG_LONG
else if (SimpleString::StrCmp(namedValue.getType().asCharString(), "long long int") == 0) {
returnValue.type = MOCKVALUETYPE_LONG_LONG_INTEGER;
returnValue.value.longLongIntValue = namedValue.getLongLongIntValue();
}
else if (SimpleString::StrCmp(namedValue.getType().asCharString(), "unsigned long long int") == 0) {
returnValue.type = MOCKVALUETYPE_UNSIGNED_LONG_LONG_INTEGER;
returnValue.value.unsignedLongLongIntValue = namedValue.getUnsignedLongLongIntValue();
}
#endif
else if (SimpleString::StrCmp(namedValue.getType().asCharString(), "double") == 0) {
returnValue.type = MOCKVALUETYPE_DOUBLE;
returnValue.value.doubleValue = namedValue.getDoubleValue();
}
else if (SimpleString::StrCmp(namedValue.getType().asCharString(), "const char*") == 0) {
returnValue.type = MOCKVALUETYPE_STRING;
returnValue.value.stringValue = namedValue.getStringValue();
}
else if (SimpleString::StrCmp(namedValue.getType().asCharString(), "void*") == 0) {
returnValue.type = MOCKVALUETYPE_POINTER;
returnValue.value.pointerValue = namedValue.getPointerValue();
}
else if (SimpleString::StrCmp(namedValue.getType().asCharString(), "const void*") == 0) {
returnValue.type = MOCKVALUETYPE_CONST_POINTER;
returnValue.value.constPointerValue = namedValue.getConstPointerValue();
}
else if (SimpleString::StrCmp(namedValue.getType().asCharString(), "void (*)()") == 0) {
returnValue.type = MOCKVALUETYPE_FUNCTIONPOINTER;
returnValue.value.functionPointerValue = (void (*)()) namedValue.getFunctionPointerValue();
}
else if (SimpleString::StrCmp(namedValue.getType().asCharString(), "const unsigned char*") == 0) {
returnValue.type = MOCKVALUETYPE_MEMORYBUFFER;
returnValue.value.memoryBufferValue = namedValue.getMemoryBuffer();
}
else {
returnValue.type = MOCKVALUETYPE_OBJECT;
returnValue.value.objectValue = namedValue.getObjectPointer();
}
return returnValue;
}
void strictOrder_c()
{
currentMockSupport->strictOrder();
}
MockExpectedCall_c* expectOneCall_c(const char* name)
{
expectedCall = ¤tMockSupport->expectOneCall(name);
return &gExpectedCall;
}
void expectNoCall_c(const char* name)
{
currentMockSupport->expectNoCall(name);
}
MockExpectedCall_c* expectNCalls_c(const unsigned int number, const char* name)
{
expectedCall = ¤tMockSupport->expectNCalls(number, name);
return &gExpectedCall;
}
MockActualCall_c* actualCall_c(const char* name)
{
actualCall = ¤tMockSupport->actualCall(name);
return &gActualCall;
}
MockActualCall_c* withActualBoolParameters_c(const char* name, int value)
{
actualCall = &actualCall->withParameter(name, (value != 0));
return &gActualCall;
}
MockActualCall_c* withActualIntParameters_c(const char* name, int value)
{
actualCall = &actualCall->withParameter(name, value);
return &gActualCall;
}
MockActualCall_c* withActualUnsignedIntParameters_c(const char* name, unsigned int value)
{
actualCall = &actualCall->withParameter(name, value);
return &gActualCall;
}
MockActualCall_c* withActualLongIntParameters_c(const char* name, long int value)
{
actualCall = &actualCall->withParameter(name, value);
return &gActualCall;
}
MockActualCall_c* withActualUnsignedLongIntParameters_c(const char* name, unsigned long int value)
{
actualCall = &actualCall->withParameter(name, value);
return &gActualCall;
}
#if CPPUTEST_USE_LONG_LONG
MockActualCall_c* withActualLongLongIntParameters_c(const char* name, cpputest_longlong value)
{
actualCall = &actualCall->withParameter(name, value);
return &gActualCall;
}
MockActualCall_c* withActualUnsignedLongLongIntParameters_c(const char* name, cpputest_ulonglong value)
{
actualCall = &actualCall->withParameter(name, value);
return &gActualCall;
}
#else
MockActualCall_c* withActualLongLongIntParameters_c(const char*, cpputest_longlong)
{
FAIL("Long Long type is not supported");
return &gActualCall;
}
MockActualCall_c* withActualUnsignedLongLongIntParameters_c(const char*, cpputest_ulonglong)
{
FAIL("Unsigned Long Long type is not supported");
return &gActualCall;
}
#endif
MockActualCall_c* withActualDoubleParameters_c(const char* name, double value)
{
actualCall = &actualCall->withParameter(name, value);
return &gActualCall;
}
MockActualCall_c* withActualStringParameters_c(const char* name, const char* value)
{
actualCall = &actualCall->withParameter(name, value);
return &gActualCall;
}
MockActualCall_c* withActualPointerParameters_c(const char* name, void* value)
{
actualCall = &actualCall->withParameter(name, value);
return &gActualCall;
}
MockActualCall_c* withActualConstPointerParameters_c(const char* name, const void* value)
{
actualCall = &actualCall->withParameter(name, value);
return &gActualCall;
}
MockActualCall_c* withActualFunctionPointerParameters_c(const char* name, void (*value)())
{
actualCall = &actualCall->withParameter(name, (cpputest_cpp_function_pointer) value);
return &gActualCall;
}
MockActualCall_c* withActualMemoryBufferParameters_c(const char* name, const unsigned char* value, size_t size)
{
actualCall = &actualCall->withParameter(name, value, size);
return &gActualCall;
}
MockActualCall_c* withActualParameterOfType_c(const char* type, const char* name, const void* value)
{
actualCall = &actualCall->withParameterOfType(type, name, value);
return &gActualCall;
}
MockActualCall_c* withActualOutputParameter_c(const char* name, void* value)
{
actualCall = &actualCall->withOutputParameter(name, value);
return &gActualCall;
}
MockActualCall_c* withActualOutputParameterOfType_c(const char* type, const char* name, void* value)
{
actualCall = &actualCall->withOutputParameterOfType(type, name, value);
return &gActualCall;
}
MockValue_c returnValue_c()
{
return getMockValueCFromNamedValue(actualCall->returnValue());
}
int boolReturnValue_c()
{
return actualCall->returnBoolValue() ? 1 : 0;
}
int returnBoolValueOrDefault_c(int defaultValue)
{
if (!hasReturnValue_c()) {
return defaultValue;
}
return boolReturnValue_c();
}
int intReturnValue_c()
{
return actualCall->returnIntValue();
}
int returnIntValueOrDefault_c(int defaultValue)
{
if (!hasReturnValue_c()) {
return defaultValue;
}
return intReturnValue_c();
}
unsigned int unsignedIntReturnValue_c()
{
return actualCall->returnUnsignedIntValue();
}
unsigned int returnUnsignedIntValueOrDefault_c(unsigned int defaultValue)
{
if (!hasReturnValue_c()) {
return defaultValue;
}
return unsignedIntReturnValue_c();
}
long int longIntReturnValue_c()
{
return actualCall->returnLongIntValue();
}
long int returnLongIntValueOrDefault_c(long int defaultValue)
{
if (!hasReturnValue_c()) {
return defaultValue;
}
return longIntReturnValue_c();
}
unsigned long int unsignedLongIntReturnValue_c()
{
return actualCall->returnUnsignedLongIntValue();
}
unsigned long int returnUnsignedLongIntValueOrDefault_c(unsigned long int defaultValue)
{
if (!hasReturnValue_c()) {
return defaultValue;
}
return unsignedLongIntReturnValue_c();
}
#if CPPUTEST_USE_LONG_LONG
cpputest_longlong longLongIntReturnValue_c()
{
return actualCall->returnLongLongIntValue();
}
cpputest_longlong returnLongLongIntValueOrDefault_c(cpputest_longlong defaultValue)
{
if (!hasReturnValue_c()) {
return defaultValue;
}
return longLongIntReturnValue_c();
}
cpputest_ulonglong unsignedLongLongIntReturnValue_c()
{
return actualCall->returnUnsignedLongLongIntValue();
}
cpputest_ulonglong returnUnsignedLongLongIntValueOrDefault_c(cpputest_ulonglong defaultValue)
{
if (!hasReturnValue_c()) {
return defaultValue;
}
return unsignedLongLongIntReturnValue_c();
}
#else
cpputest_longlong longLongIntReturnValue_c()
{
FAIL("Long Long type is not supported");
cpputest_longlong ret = {};
return ret;
}
cpputest_longlong returnLongLongIntValueOrDefault_c(cpputest_longlong)
{
FAIL("Long Long type is not supported");
cpputest_longlong ret = {};
return ret;
}
cpputest_ulonglong unsignedLongLongIntReturnValue_c()
{
FAIL("Unsigned Long Long type is not supported");
cpputest_ulonglong ret = {};
return ret;
}
cpputest_ulonglong returnUnsignedLongLongIntValueOrDefault_c(cpputest_ulonglong)
{
FAIL("Unsigned Long Long type is not supported");
cpputest_ulonglong ret = {};
return ret;
}
#endif
const char* stringReturnValue_c()
{
return actualCall->returnStringValue();
}
const char* returnStringValueOrDefault_c(const char * defaultValue)
{
if (!hasReturnValue_c()) {
return defaultValue;
}
return stringReturnValue_c();
}
double doubleReturnValue_c()
{
return actualCall->returnDoubleValue();
}
double returnDoubleValueOrDefault_c(double defaultValue)
{
if (!hasReturnValue_c()) {
return defaultValue;
}
return doubleReturnValue_c();
}
void* pointerReturnValue_c()
{
return actualCall->returnPointerValue();
}
void* returnPointerValueOrDefault_c(void * defaultValue)
{
if (!hasReturnValue_c()) {
return defaultValue;
}
return pointerReturnValue_c();
}
const void* constPointerReturnValue_c()
{
return actualCall->returnConstPointerValue();
}
const void* returnConstPointerValueOrDefault_c(const void * defaultValue)
{
if (!hasReturnValue_c()) {
return defaultValue;
}
return constPointerReturnValue_c();
}
void (*functionPointerReturnValue_c())()
{
return (void (*)()) actualCall->returnFunctionPointerValue();
}
void (*returnFunctionPointerValueOrDefault_c(void (*defaultValue)()))()
{
if (!hasReturnValue_c()) {
return defaultValue;
}
return functionPointerReturnValue_c();
}
void disable_c()
{
currentMockSupport->disable();
}
void enable_c()
{
currentMockSupport->enable();
}
void ignoreOtherCalls_c()
{
currentMockSupport->ignoreOtherCalls();
}
void setBoolData_c(const char* name, int value)
{
currentMockSupport->setData(name, (value != 0));
}
void setIntData_c(const char* name, int value)
{
currentMockSupport->setData(name, value);
}
void setUnsignedIntData_c(const char* name, unsigned int value)
{
currentMockSupport->setData(name, value);
}
void setDoubleData_c(const char* name, double value)
{
currentMockSupport->setData(name, value);
}
void setStringData_c(const char* name, const char* value)
{
currentMockSupport->setData(name, value);
}
void setPointerData_c(const char* name, void* value)
{
currentMockSupport->setData(name, value);
}
void setConstPointerData_c(const char* name, const void* value)
{
currentMockSupport->setData(name, value);
}
void setFunctionPointerData_c(const char* name, void (*value)())
{
currentMockSupport->setData(name, (cpputest_cpp_function_pointer) value);
}
void setDataObject_c(const char* name, const char* type, void* value)
{
currentMockSupport->setDataObject(name, type, value);
}
void setDataConstObject_c(const char* name, const char* type, const void* value)
{
currentMockSupport->setDataConstObject(name, type, value);
}
MockValue_c getData_c(const char* name)
{
return getMockValueCFromNamedValue(currentMockSupport->getData(name));
}
int hasReturnValue_c()
{
return currentMockSupport->hasReturnValue();
}
void checkExpectations_c()
{
currentMockSupport->checkExpectations();
}
int expectedCallsLeft_c()
{
return currentMockSupport->expectedCallsLeft();
}
void clear_c()
{
currentMockSupport->clear();
}
void crashOnFailure_c(unsigned shouldCrash)
{
currentMockSupport->crashOnFailure(0 != shouldCrash);
}
MockSupport_c* mock_c()
{
currentMockSupport = &mock("", &failureReporterForC);
return &gMockSupport;
}
MockSupport_c* mock_scope_c(const char* scope)
{
currentMockSupport = &mock(scope, &failureReporterForC);
return &gMockSupport;
}
}
| null |
36 | cpp | cpputest | MockNamedValue.cpp | src/CppUTestExt/MockNamedValue.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/TestHarness.h"
#include "CppUTestExt/MockNamedValue.h"
#include "CppUTest/PlatformSpecificFunctions.h"
MockNamedValueComparatorsAndCopiersRepository* MockNamedValue::defaultRepository_ = NULLPTR;
const double MockNamedValue::defaultDoubleTolerance = 0.005;
void MockNamedValue::setDefaultComparatorsAndCopiersRepository(MockNamedValueComparatorsAndCopiersRepository* repository)
{
defaultRepository_ = repository;
}
MockNamedValueComparatorsAndCopiersRepository* MockNamedValue::getDefaultComparatorsAndCopiersRepository()
{
return defaultRepository_;
}
MockNamedValue::MockNamedValue(const SimpleString& name) : name_(name), type_("int"), size_(0), comparator_(NULLPTR), copier_(NULLPTR)
{
value_.intValue_ = 0;
}
MockNamedValue::~MockNamedValue()
{
}
void MockNamedValue::setValue(bool value)
{
type_ = "bool";
value_.boolValue_ = value;
}
void MockNamedValue::setValue(unsigned int value)
{
type_ = "unsigned int";
value_.unsignedIntValue_ = value;
}
void MockNamedValue::setValue(int value)
{
type_ = "int";
value_.intValue_ = value;
}
void MockNamedValue::setValue(long int value)
{
type_ = "long int";
value_.longIntValue_ = value;
}
void MockNamedValue::setValue(unsigned long int value)
{
type_ = "unsigned long int";
value_.unsignedLongIntValue_ = value;
}
#if CPPUTEST_USE_LONG_LONG
void MockNamedValue::setValue(cpputest_longlong value)
{
type_ = "long long int";
value_.longLongIntValue_ = value;
}
void MockNamedValue::setValue(cpputest_ulonglong value)
{
type_ = "unsigned long long int";
value_.unsignedLongLongIntValue_ = value;
}
#else
void MockNamedValue::setValue(cpputest_longlong)
{
FAIL("Long Long type is not supported");
}
void MockNamedValue::setValue(cpputest_ulonglong)
{
FAIL("Unsigned Long Long type is not supported");
}
#endif
void MockNamedValue::setValue(double value)
{
setValue(value, defaultDoubleTolerance);
}
void MockNamedValue::setValue(double value, double tolerance)
{
type_ = "double";
value_.doubleValue_.value = value;
value_.doubleValue_.tolerance = tolerance;
}
void MockNamedValue::setValue(void* value)
{
type_ = "void*";
value_.pointerValue_ = value;
}
void MockNamedValue::setValue(const void* value)
{
type_ = "const void*";
value_.constPointerValue_ = value;
}
void MockNamedValue::setValue(void (*value)())
{
type_ = "void (*)()";
value_.functionPointerValue_ = value;
}
void MockNamedValue::setValue(const char* value)
{
type_ = "const char*";
value_.stringValue_ = value;
}
void MockNamedValue::setMemoryBuffer(const unsigned char* value, size_t size)
{
type_ = "const unsigned char*";
value_.memoryBufferValue_ = value;
size_ = size;
}
void MockNamedValue::setConstObjectPointer(const SimpleString& type, const void* objectPtr)
{
type_ = type;
value_.constObjectPointerValue_ = objectPtr;
if (defaultRepository_)
{
comparator_ = defaultRepository_->getComparatorForType(type);
copier_ = defaultRepository_->getCopierForType(type);
}
}
void MockNamedValue::setObjectPointer(const SimpleString& type, void* objectPtr)
{
type_ = type;
value_.objectPointerValue_ = objectPtr;
if (defaultRepository_)
{
comparator_ = defaultRepository_->getComparatorForType(type);
copier_ = defaultRepository_->getCopierForType(type);
}
}
void MockNamedValue::setSize(size_t size)
{
size_ = size;
}
void MockNamedValue::setName(const char* name)
{
name_ = name;
}
SimpleString MockNamedValue::getName() const
{
return name_;
}
SimpleString MockNamedValue::getType() const
{
return type_;
}
bool MockNamedValue::getBoolValue() const
{
STRCMP_EQUAL("bool", type_.asCharString());
return value_.boolValue_;
}
unsigned int MockNamedValue::getUnsignedIntValue() const
{
if(type_ == "int" && value_.intValue_ >= 0)
return (unsigned int)value_.intValue_;
else
{
STRCMP_EQUAL("unsigned int", type_.asCharString());
return value_.unsignedIntValue_;
}
}
int MockNamedValue::getIntValue() const
{
STRCMP_EQUAL("int", type_.asCharString());
return value_.intValue_;
}
long int MockNamedValue::getLongIntValue() const
{
if(type_ == "int")
return value_.intValue_;
else if(type_ == "unsigned int")
return (long int)value_.unsignedIntValue_;
else
{
STRCMP_EQUAL("long int", type_.asCharString());
return value_.longIntValue_;
}
}
unsigned long int MockNamedValue::getUnsignedLongIntValue() const
{
if(type_ == "unsigned int")
return value_.unsignedIntValue_;
else if(type_ == "int" && value_.intValue_ >= 0)
return (unsigned long int)value_.intValue_;
else if(type_ == "long int" && value_.longIntValue_ >= 0)
return (unsigned long int)value_.longIntValue_;
else
{
STRCMP_EQUAL("unsigned long int", type_.asCharString());
return value_.unsignedLongIntValue_;
}
}
#if CPPUTEST_USE_LONG_LONG
cpputest_longlong MockNamedValue::getLongLongIntValue() const
{
if(type_ == "int")
return value_.intValue_;
else if(type_ == "unsigned int")
return (long long int)value_.unsignedIntValue_;
else if(type_ == "long int")
return value_.longIntValue_;
else if(type_ == "unsigned long int")
return (long long int)value_.unsignedLongIntValue_;
else
{
STRCMP_EQUAL("long long int", type_.asCharString());
return value_.longLongIntValue_;
}
}
cpputest_ulonglong MockNamedValue::getUnsignedLongLongIntValue() const
{
if(type_ == "unsigned int")
return value_.unsignedIntValue_;
else if(type_ == "int" && value_.intValue_ >= 0)
return (unsigned long long int)value_.intValue_;
else if(type_ == "long int" && value_.longIntValue_ >= 0)
return (unsigned long long int)value_.longIntValue_;
else if(type_ == "unsigned long int")
return value_.unsignedLongIntValue_;
else if(type_ == "long long int" && value_.longLongIntValue_ >= 0)
return (unsigned long long int)value_.longLongIntValue_;
else
{
STRCMP_EQUAL("unsigned long long int", type_.asCharString());
return value_.unsignedLongLongIntValue_;
}
}
#else
cpputest_longlong MockNamedValue::getLongLongIntValue() const
{
FAIL("Long Long type is not supported");
cpputest_longlong ret = {};
return ret;
}
cpputest_ulonglong MockNamedValue::getUnsignedLongLongIntValue() const
{
FAIL("Unsigned Long Long type is not supported");
cpputest_ulonglong ret = {};
return ret;
}
#endif
double MockNamedValue::getDoubleValue() const
{
STRCMP_EQUAL("double", type_.asCharString());
return value_.doubleValue_.value;
}
double MockNamedValue::getDoubleTolerance() const
{
STRCMP_EQUAL("double", type_.asCharString());
return value_.doubleValue_.tolerance;
}
const char* MockNamedValue::getStringValue() const
{
STRCMP_EQUAL("const char*", type_.asCharString());
return value_.stringValue_;
}
void* MockNamedValue::getPointerValue() const
{
STRCMP_EQUAL("void*", type_.asCharString());
return value_.pointerValue_;
}
const void* MockNamedValue::getConstPointerValue() const
{
STRCMP_EQUAL("const void*", type_.asCharString());
return value_.pointerValue_;
}
void (*MockNamedValue::getFunctionPointerValue() const)()
{
STRCMP_EQUAL("void (*)()", type_.asCharString());
return value_.functionPointerValue_;
}
const unsigned char* MockNamedValue::getMemoryBuffer() const
{
STRCMP_EQUAL("const unsigned char*", type_.asCharString());
return value_.memoryBufferValue_;
}
const void* MockNamedValue::getConstObjectPointer() const
{
return value_.constObjectPointerValue_;
}
void* MockNamedValue::getObjectPointer() const
{
return value_.objectPointerValue_;
}
size_t MockNamedValue::getSize() const
{
return size_;
}
MockNamedValueComparator* MockNamedValue::getComparator() const
{
return comparator_;
}
MockNamedValueCopier* MockNamedValue::getCopier() const
{
return copier_;
}
bool MockNamedValue::equals(const MockNamedValue& p) const
{
if((type_ == "long int") && (p.type_ == "int"))
return value_.longIntValue_ == p.value_.intValue_;
else if((type_ == "int") && (p.type_ == "long int"))
return value_.intValue_ == p.value_.longIntValue_;
else if((type_ == "unsigned int") && (p.type_ == "int"))
return (p.value_.intValue_ >= 0) && (value_.unsignedIntValue_ == (unsigned int)p.value_.intValue_);
else if((type_ == "int") && (p.type_ == "unsigned int"))
return (value_.intValue_ >= 0) && ((unsigned int)value_.intValue_ == p.value_.unsignedIntValue_);
else if((type_ == "unsigned long int") && (p.type_ == "int"))
return (p.value_.intValue_ >= 0) && (value_.unsignedLongIntValue_ == (unsigned long)p.value_.intValue_);
else if((type_ == "int") && (p.type_ == "unsigned long int"))
return (value_.intValue_ >= 0) && ((unsigned long)value_.intValue_ == p.value_.unsignedLongIntValue_);
else if((type_ == "unsigned int") && (p.type_ == "long int"))
return (p.value_.longIntValue_ >= 0) && (value_.unsignedIntValue_ == (unsigned long)p.value_.longIntValue_);
else if((type_ == "long int") && (p.type_ == "unsigned int"))
return (value_.longIntValue_ >= 0) && ((unsigned long)value_.longIntValue_ == p.value_.unsignedIntValue_);
else if((type_ == "unsigned int") && (p.type_ == "unsigned long int"))
return value_.unsignedIntValue_ == p.value_.unsignedLongIntValue_;
else if((type_ == "unsigned long int") && (p.type_ == "unsigned int"))
return value_.unsignedLongIntValue_ == p.value_.unsignedIntValue_;
else if((type_ == "long int") && (p.type_ == "unsigned long int"))
return (value_.longIntValue_ >= 0) && ((unsigned long)value_.longIntValue_ == p.value_.unsignedLongIntValue_);
else if((type_ == "unsigned long int") && (p.type_ == "long int"))
return (p.value_.longIntValue_ >= 0) && (value_.unsignedLongIntValue_ == (unsigned long) p.value_.longIntValue_);
#if CPPUTEST_USE_LONG_LONG
else if ((type_ == "long long int") && (p.type_ == "int"))
return value_.longLongIntValue_ == p.value_.intValue_;
else if ((type_ == "int") && (p.type_ == "long long int"))
return value_.intValue_ == p.value_.longLongIntValue_;
else if ((type_ == "long long int") && (p.type_ == "long int"))
return value_.longLongIntValue_ == p.value_.longIntValue_;
else if ((type_ == "long int") && (p.type_ == "long long int"))
return value_.longIntValue_ == p.value_.longLongIntValue_;
else if ((type_ == "long long int") && (p.type_ == "unsigned int"))
return (value_.longLongIntValue_ >= 0) && ((unsigned long long)value_.longLongIntValue_ == p.value_.unsignedIntValue_);
else if ((type_ == "unsigned int") && (p.type_ == "long long int"))
return (p.value_.longLongIntValue_ >= 0) && (value_.unsignedIntValue_ == (unsigned long long)p.value_.longLongIntValue_);
else if ((type_ == "long long int") && (p.type_ == "unsigned long int"))
return (value_.longLongIntValue_ >= 0) && ((unsigned long long)value_.longLongIntValue_ == p.value_.unsignedLongIntValue_);
else if ((type_ == "unsigned long int") && (p.type_ == "long long int"))
return (p.value_.longLongIntValue_ >= 0) && (value_.unsignedLongIntValue_ == (unsigned long long)p.value_.longLongIntValue_);
else if ((type_ == "long long int") && (p.type_ == "unsigned long long int"))
return (value_.longLongIntValue_ >= 0) && ((unsigned long long)value_.longLongIntValue_ == p.value_.unsignedLongLongIntValue_);
else if ((type_ == "unsigned long long int") && (p.type_ == "long long int"))
return (p.value_.longLongIntValue_ >= 0) && (value_.unsignedLongLongIntValue_ == (unsigned long long)p.value_.longLongIntValue_);
else if ((type_ == "unsigned long long int") && (p.type_ == "int"))
return (p.value_.intValue_ >= 0) && (value_.unsignedLongLongIntValue_ == (unsigned long long)p.value_.intValue_);
else if ((type_ == "int") && (p.type_ == "unsigned long long int"))
return (value_.intValue_ >= 0) && ((unsigned long long)value_.intValue_ == p.value_.unsignedLongLongIntValue_);
else if ((type_ == "unsigned long long int") && (p.type_ == "unsigned int"))
return value_.unsignedLongLongIntValue_ == p.value_.unsignedIntValue_;
else if ((type_ == "unsigned int") && (p.type_ == "unsigned long long int"))
return value_.unsignedIntValue_ == p.value_.unsignedLongLongIntValue_;
else if ((type_ == "unsigned long long int") && (p.type_ == "long int"))
return (p.value_.longIntValue_ >= 0) && (value_.unsignedLongLongIntValue_ == (unsigned long long)p.value_.longIntValue_);
else if ((type_ == "long int") && (p.type_ == "unsigned long long int"))
return (value_.longIntValue_ >= 0) && ((unsigned long long)value_.longIntValue_ == p.value_.unsignedLongLongIntValue_);
else if ((type_ == "unsigned long long int") && (p.type_ == "unsigned long int"))
return value_.unsignedLongLongIntValue_ == p.value_.unsignedLongIntValue_;
else if ((type_ == "unsigned long int") && (p.type_ == "unsigned long long int"))
return value_.unsignedLongIntValue_ == p.value_.unsignedLongLongIntValue_;
#endif
if (type_ != p.type_) return false;
if (type_ == "bool")
return value_.boolValue_ == p.value_.boolValue_;
else if (type_ == "int")
return value_.intValue_ == p.value_.intValue_;
else if (type_ == "unsigned int")
return value_.unsignedIntValue_ == p.value_.unsignedIntValue_;
else if (type_ == "long int")
return value_.longIntValue_ == p.value_.longIntValue_;
else if (type_ == "unsigned long int")
return value_.unsignedLongIntValue_ == p.value_.unsignedLongIntValue_;
#if CPPUTEST_USE_LONG_LONG
else if (type_ == "long long int")
return value_.longLongIntValue_ == p.value_.longLongIntValue_;
else if (type_ == "unsigned long long int")
return value_.unsignedLongLongIntValue_ == p.value_.unsignedLongLongIntValue_;
#endif
else if (type_ == "const char*")
return SimpleString(value_.stringValue_) == SimpleString(p.value_.stringValue_);
else if (type_ == "void*")
return value_.pointerValue_ == p.value_.pointerValue_;
else if (type_ == "const void*")
return value_.constPointerValue_ == p.value_.constPointerValue_;
else if (type_ == "void (*)()")
return value_.functionPointerValue_ == p.value_.functionPointerValue_;
else if (type_ == "double")
return (doubles_equal(value_.doubleValue_.value, p.value_.doubleValue_.value, value_.doubleValue_.tolerance));
else if (type_ == "const unsigned char*")
{
if (size_ != p.size_) {
return false;
}
return SimpleString::MemCmp(value_.memoryBufferValue_, p.value_.memoryBufferValue_, size_) == 0;
}
if (comparator_)
return comparator_->isEqual(value_.constObjectPointerValue_, p.value_.constObjectPointerValue_);
return false;
}
bool MockNamedValue::compatibleForCopying(const MockNamedValue& p) const
{
if (type_ == p.type_) return true;
if ((type_ == "const void*") && (p.type_ == "void*"))
return true;
return false;
}
SimpleString MockNamedValue::toString() const
{
if (type_ == "bool")
return StringFrom(value_.boolValue_);
else if (type_ == "int")
return StringFrom(value_.intValue_) + " " + BracketsFormattedHexStringFrom(value_.intValue_);
else if (type_ == "unsigned int")
return StringFrom(value_.unsignedIntValue_) + " " + BracketsFormattedHexStringFrom(value_.unsignedIntValue_);
else if (type_ == "long int")
return StringFrom(value_.longIntValue_) + " " + BracketsFormattedHexStringFrom(value_.longIntValue_);
else if (type_ == "unsigned long int")
return StringFrom(value_.unsignedLongIntValue_) + " " + BracketsFormattedHexStringFrom(value_.unsignedLongIntValue_);
#if CPPUTEST_USE_LONG_LONG
else if (type_ == "long long int")
return StringFrom(value_.longLongIntValue_) + " " + BracketsFormattedHexStringFrom(value_.longLongIntValue_);
else if (type_ == "unsigned long long int")
return StringFrom(value_.unsignedLongLongIntValue_) + " " + BracketsFormattedHexStringFrom(value_.unsignedLongLongIntValue_);
#endif
else if (type_ == "const char*")
return value_.stringValue_;
else if (type_ == "void*")
return StringFrom(value_.pointerValue_);
else if (type_ == "void (*)()")
return StringFrom(value_.functionPointerValue_);
else if (type_ == "const void*")
return StringFrom(value_.constPointerValue_);
else if (type_ == "double")
return StringFrom(value_.doubleValue_.value);
else if (type_ == "const unsigned char*")
return StringFromBinaryWithSizeOrNull(value_.memoryBufferValue_, size_);
if (comparator_)
return comparator_->valueToString(value_.constObjectPointerValue_);
return StringFromFormat("No comparator found for type: \"%s\"", type_.asCharString());
}
void MockNamedValueListNode::setNext(MockNamedValueListNode* node)
{
next_ = node;
}
MockNamedValueListNode* MockNamedValueListNode::next()
{
return next_;
}
MockNamedValue* MockNamedValueListNode::item()
{
return data_;
}
void MockNamedValueListNode::destroy()
{
delete data_;
}
MockNamedValueListNode::MockNamedValueListNode(MockNamedValue* newValue)
: data_(newValue), next_(NULLPTR)
{
}
SimpleString MockNamedValueListNode::getName() const
{
return data_->getName();
}
SimpleString MockNamedValueListNode::getType() const
{
return data_->getType();
}
MockNamedValueList::MockNamedValueList() : head_(NULLPTR)
{
}
void MockNamedValueList::clear()
{
while (head_) {
MockNamedValueListNode* n = head_->next();
head_->destroy();
delete head_;
head_ = n;
}
}
void MockNamedValueList::add(MockNamedValue* newValue)
{
MockNamedValueListNode* newNode = new MockNamedValueListNode(newValue);
if (head_ == NULLPTR)
head_ = newNode;
else {
MockNamedValueListNode* lastNode = head_;
while (lastNode->next()) lastNode = lastNode->next();
lastNode->setNext(newNode);
}
}
MockNamedValue* MockNamedValueList::getValueByName(const SimpleString& name)
{
for (MockNamedValueListNode * p = head_; p; p = p->next())
if (p->getName() == name)
return p->item();
return NULLPTR;
}
MockNamedValueListNode* MockNamedValueList::begin()
{
return head_;
}
struct MockNamedValueComparatorsAndCopiersRepositoryNode
{
MockNamedValueComparatorsAndCopiersRepositoryNode(const SimpleString& name, MockNamedValueComparator* comparator, MockNamedValueComparatorsAndCopiersRepositoryNode* next)
: name_(name), comparator_(comparator), copier_(NULLPTR), next_(next) {}
MockNamedValueComparatorsAndCopiersRepositoryNode(const SimpleString& name, MockNamedValueCopier* copier, MockNamedValueComparatorsAndCopiersRepositoryNode* next)
: name_(name), comparator_(NULLPTR), copier_(copier), next_(next) {}
MockNamedValueComparatorsAndCopiersRepositoryNode(const SimpleString& name, MockNamedValueComparator* comparator, MockNamedValueCopier* copier, MockNamedValueComparatorsAndCopiersRepositoryNode* next)
: name_(name), comparator_(comparator), copier_(copier), next_(next) {}
SimpleString name_;
MockNamedValueComparator* comparator_;
MockNamedValueCopier* copier_;
MockNamedValueComparatorsAndCopiersRepositoryNode* next_;
};
MockNamedValueComparatorsAndCopiersRepository::MockNamedValueComparatorsAndCopiersRepository() : head_(NULLPTR)
{
}
MockNamedValueComparatorsAndCopiersRepository::~MockNamedValueComparatorsAndCopiersRepository()
{
clear();
}
void MockNamedValueComparatorsAndCopiersRepository::clear()
{
while (head_) {
MockNamedValueComparatorsAndCopiersRepositoryNode* next = head_->next_;
delete head_;
head_ = next;
}
}
void MockNamedValueComparatorsAndCopiersRepository::installComparator(const SimpleString& name, MockNamedValueComparator& comparator)
{
head_ = new MockNamedValueComparatorsAndCopiersRepositoryNode(name, &comparator, head_);
}
void MockNamedValueComparatorsAndCopiersRepository::installCopier(const SimpleString& name, MockNamedValueCopier& copier)
{
head_ = new MockNamedValueComparatorsAndCopiersRepositoryNode(name, &copier, head_);
}
MockNamedValueComparator* MockNamedValueComparatorsAndCopiersRepository::getComparatorForType(const SimpleString& name)
{
for (MockNamedValueComparatorsAndCopiersRepositoryNode* p = head_; p; p = p->next_)
if (p->name_ == name && p->comparator_) return p->comparator_;
return NULLPTR;
}
MockNamedValueCopier* MockNamedValueComparatorsAndCopiersRepository::getCopierForType(const SimpleString& name)
{
for (MockNamedValueComparatorsAndCopiersRepositoryNode* p = head_; p; p = p->next_)
if (p->name_ == name && p->copier_) return p->copier_;
return NULLPTR;
}
void MockNamedValueComparatorsAndCopiersRepository::installComparatorsAndCopiers(const MockNamedValueComparatorsAndCopiersRepository& repository)
{
for (MockNamedValueComparatorsAndCopiersRepositoryNode* p = repository.head_; p; p = p->next_)
head_ = new MockNamedValueComparatorsAndCopiersRepositoryNode(p->name_, p->comparator_, p->copier_, head_);
}
| null |
37 | cpp | cpputest | MockExpectedCallsList.cpp | src/CppUTestExt/MockExpectedCallsList.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/TestHarness.h"
#include "CppUTestExt/MockExpectedCallsList.h"
#include "CppUTestExt/MockCheckedExpectedCall.h"
MockExpectedCallsList::MockExpectedCallsList() : head_(NULLPTR)
{
}
MockExpectedCallsList::~MockExpectedCallsList()
{
while (head_) {
MockExpectedCallsListNode* next = head_->next_;
delete head_;
head_ = next;
}
}
bool MockExpectedCallsList::hasCallsOutOfOrder() const
{
for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
if (p->expectedCall_->isOutOfOrder())
return true;
return false;
}
unsigned int MockExpectedCallsList::size() const
{
unsigned int count = 0;
for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
count++;
return count;
}
bool MockExpectedCallsList::isEmpty() const
{
return head_ == NULLPTR;
}
unsigned int MockExpectedCallsList::amountOfActualCallsFulfilledFor(const SimpleString& name) const
{
unsigned int count = 0;
for (MockExpectedCallsListNode* p = head_; p; p = p->next_) {
if (p->expectedCall_->relatesTo(name)) {
count += p->expectedCall_->getActualCallsFulfilled();
}
}
return count;
}
unsigned int MockExpectedCallsList::amountOfUnfulfilledExpectations() const
{
unsigned int count = 0;
for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
if (! p->expectedCall_->isFulfilled()) count++;
return count;
}
bool MockExpectedCallsList::hasFinalizedMatchingExpectations() const
{
for (MockExpectedCallsListNode* p = head_; p; p = p->next_) {
if (p->expectedCall_->isMatchingActualCallAndFinalized()) {
return true;
}
}
return false;
}
bool MockExpectedCallsList::hasUnfulfilledExpectations() const
{
for (MockExpectedCallsListNode* p = head_; p; p = p->next_) {
if (!p->expectedCall_->isFulfilled()) {
return true;
}
}
return false;
}
bool MockExpectedCallsList::hasExpectationWithName(const SimpleString& name) const
{
for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
if (p->expectedCall_->relatesTo(name))
return true;
return false;
}
void MockExpectedCallsList::addExpectedCall(MockCheckedExpectedCall* call)
{
MockExpectedCallsListNode* newCall = new MockExpectedCallsListNode(call);
if (head_ == NULLPTR)
head_ = newCall;
else {
MockExpectedCallsListNode* lastCall = head_;
while (lastCall->next_) lastCall = lastCall->next_;
lastCall->next_ = newCall;
}
}
void MockExpectedCallsList::addPotentiallyMatchingExpectations(const MockExpectedCallsList& list)
{
for (MockExpectedCallsListNode* p = list.head_; p; p = p->next_)
if (p->expectedCall_->canMatchActualCalls())
addExpectedCall(p->expectedCall_);
}
void MockExpectedCallsList::addExpectationsRelatedTo(const SimpleString& name, const MockExpectedCallsList& list)
{
for (MockExpectedCallsListNode* p = list.head_; p; p = p->next_)
if (p->expectedCall_->relatesTo(name))
addExpectedCall(p->expectedCall_);
}
void MockExpectedCallsList::addExpectations(const MockExpectedCallsList& list)
{
for (MockExpectedCallsListNode* p = list.head_; p; p = p->next_)
addExpectedCall(p->expectedCall_);
}
void MockExpectedCallsList::onlyKeepExpectationsRelatedTo(const SimpleString& name)
{
for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
if (! p->expectedCall_->relatesTo(name))
p->expectedCall_ = NULLPTR;
pruneEmptyNodeFromList();
}
void MockExpectedCallsList::onlyKeepOutOfOrderExpectations()
{
for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
if (!p->expectedCall_->isOutOfOrder())
p->expectedCall_ = NULLPTR;
pruneEmptyNodeFromList();
}
void MockExpectedCallsList::onlyKeepUnmatchingExpectations()
{
for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
if (p->expectedCall_->isMatchingActualCallAndFinalized())
{
p->expectedCall_->resetActualCallMatchingState();
p->expectedCall_ = NULLPTR;
}
pruneEmptyNodeFromList();
}
void MockExpectedCallsList::onlyKeepExpectationsWithInputParameterName(const SimpleString& name)
{
for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
if (! p->expectedCall_->hasInputParameterWithName(name))
p->expectedCall_ = NULLPTR;
pruneEmptyNodeFromList();
}
void MockExpectedCallsList::onlyKeepExpectationsWithOutputParameterName(const SimpleString& name)
{
for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
if (! p->expectedCall_->hasOutputParameterWithName(name))
p->expectedCall_ = NULLPTR;
pruneEmptyNodeFromList();
}
void MockExpectedCallsList::onlyKeepExpectationsWithInputParameter(const MockNamedValue& parameter)
{
for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
if (! p->expectedCall_->hasInputParameter(parameter))
p->expectedCall_ = NULLPTR;
pruneEmptyNodeFromList();
}
void MockExpectedCallsList::onlyKeepExpectationsWithOutputParameter(const MockNamedValue& parameter)
{
for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
if (! p->expectedCall_->hasOutputParameter(parameter))
p->expectedCall_ = NULLPTR;
pruneEmptyNodeFromList();
}
void MockExpectedCallsList::onlyKeepExpectationsOnObject(const void* objectPtr)
{
for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
if (! p->expectedCall_->relatesToObject(objectPtr))
p->expectedCall_ = NULLPTR;
pruneEmptyNodeFromList();
}
MockCheckedExpectedCall* MockExpectedCallsList::removeFirstFinalizedMatchingExpectation()
{
for (MockExpectedCallsListNode* p = head_; p; p = p->next_) {
if (p->expectedCall_->isMatchingActualCallAndFinalized()) {
MockCheckedExpectedCall* matchingCall = p->expectedCall_;
p->expectedCall_ = NULLPTR;
pruneEmptyNodeFromList();
return matchingCall;
}
}
return NULLPTR;
}
MockCheckedExpectedCall* MockExpectedCallsList::getFirstMatchingExpectation()
{
for (MockExpectedCallsListNode* p = head_; p; p = p->next_) {
if (p->expectedCall_->isMatchingActualCall()) {
return p->expectedCall_;
}
}
return NULLPTR;
}
MockCheckedExpectedCall* MockExpectedCallsList::removeFirstMatchingExpectation()
{
for (MockExpectedCallsListNode* p = head_; p; p = p->next_) {
if (p->expectedCall_->isMatchingActualCall()) {
MockCheckedExpectedCall* matchingCall = p->expectedCall_;
p->expectedCall_ = NULLPTR;
pruneEmptyNodeFromList();
return matchingCall;
}
}
return NULLPTR;
}
void MockExpectedCallsList::pruneEmptyNodeFromList()
{
MockExpectedCallsListNode* current = head_;
MockExpectedCallsListNode* previous = NULLPTR;
MockExpectedCallsListNode* toBeDeleted = NULLPTR;
while (current) {
if (current->expectedCall_ == NULLPTR) {
toBeDeleted = current;
if (previous == NULLPTR)
head_ = current = current->next_;
else
current = previous->next_ = current->next_;
delete toBeDeleted;
}
else {
previous = current;
current = current->next_;
}
}
}
void MockExpectedCallsList::deleteAllExpectationsAndClearList()
{
while (head_) {
MockExpectedCallsListNode* next = head_->next_;
delete head_->expectedCall_;
delete head_;
head_ = next;
}
}
void MockExpectedCallsList::resetActualCallMatchingState()
{
for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
p->expectedCall_->resetActualCallMatchingState();
}
void MockExpectedCallsList::wasPassedToObject()
{
for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
p->expectedCall_->wasPassedToObject();
}
void MockExpectedCallsList::parameterWasPassed(const SimpleString& parameterName)
{
for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
p->expectedCall_->inputParameterWasPassed(parameterName);
}
void MockExpectedCallsList::outputParameterWasPassed(const SimpleString& parameterName)
{
for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
p->expectedCall_->outputParameterWasPassed(parameterName);
}
static SimpleString stringOrNoneTextWhenEmpty(const SimpleString& inputString, const SimpleString& linePrefix)
{
SimpleString str = inputString;
if (str == "") {
str += linePrefix;
str += "<none>";
}
return str;
}
static SimpleString appendStringOnANewLine(const SimpleString& inputString, const SimpleString& linePrefix, const SimpleString& stringToAppend)
{
SimpleString str = inputString;
if (str != "") str += "\n";
str += linePrefix;
str += stringToAppend;
return str;
}
SimpleString MockExpectedCallsList::unfulfilledCallsToString(const SimpleString& linePrefix) const
{
SimpleString str;
for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
if (!p->expectedCall_->isFulfilled())
str = appendStringOnANewLine(str, linePrefix, p->expectedCall_->callToString());
return stringOrNoneTextWhenEmpty(str, linePrefix);
}
SimpleString MockExpectedCallsList::fulfilledCallsToString(const SimpleString& linePrefix) const
{
SimpleString str;
for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
if (p->expectedCall_->isFulfilled())
str = appendStringOnANewLine(str, linePrefix, p->expectedCall_->callToString());
return stringOrNoneTextWhenEmpty(str, linePrefix);
}
SimpleString MockExpectedCallsList::callsWithMissingParametersToString(const SimpleString& linePrefix,
const SimpleString& missingParametersPrefix) const
{
SimpleString str;
for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
{
str = appendStringOnANewLine(str, linePrefix, p->expectedCall_->callToString());
str = appendStringOnANewLine(str, linePrefix + missingParametersPrefix, p->expectedCall_->missingParametersToString());
}
return stringOrNoneTextWhenEmpty(str, linePrefix);
}
bool MockExpectedCallsList::hasUnmatchingExpectationsBecauseOfMissingParameters() const
{
for (MockExpectedCallsListNode* p = head_; p; p = p->next_)
if (! p->expectedCall_->areParametersMatchingActualCall())
return true;
return false;
}
| null |
38 | cpp | cpputest | MockSupport.cpp | src/CppUTestExt/MockSupport.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/TestHarness.h"
#include "CppUTestExt/MockSupport.h"
#include "CppUTestExt/MockActualCall.h"
#include "CppUTestExt/MockExpectedCall.h"
#include "CppUTestExt/MockFailure.h"
#define MOCK_SUPPORT_SCOPE_PREFIX "!!!$$$MockingSupportScope$$$!!!"
static MockSupport global_mock;
MockSupport& mock(const SimpleString& mockName, MockFailureReporter* failureReporterForThisCall)
{
MockSupport& mock_support = (mockName != "") ? *global_mock.getMockSupportScope(mockName) : global_mock;
mock_support.setActiveReporter(failureReporterForThisCall);
mock_support.setDefaultComparatorsAndCopiersRepository();
return mock_support;
}
MockSupport::MockSupport(const SimpleString& mockName)
:
actualCallOrder_(0),
expectedCallOrder_(0),
strictOrdering_(false),
activeReporter_(NULLPTR),
standardReporter_(&defaultReporter_),
ignoreOtherCalls_(false),
enabled_(true),
lastActualFunctionCall_(NULLPTR),
mockName_(mockName),
tracing_(false)
{
}
MockSupport::~MockSupport()
{
}
void MockSupport::crashOnFailure(bool shouldCrash)
{
activeReporter_->crashOnFailure(shouldCrash);
}
void MockSupport::setMockFailureStandardReporter(MockFailureReporter* reporter)
{
standardReporter_ = (reporter != NULLPTR) ? reporter : &defaultReporter_;
if (lastActualFunctionCall_)
lastActualFunctionCall_->setMockFailureReporter(standardReporter_);
for (MockNamedValueListNode* p = data_.begin(); p; p = p->next())
if (getMockSupport(p)) getMockSupport(p)->setMockFailureStandardReporter(standardReporter_);
}
void MockSupport::setActiveReporter(MockFailureReporter* reporter)
{
activeReporter_ = (reporter) ? reporter : standardReporter_;
}
void MockSupport::setDefaultComparatorsAndCopiersRepository()
{
MockNamedValue::setDefaultComparatorsAndCopiersRepository(&comparatorsAndCopiersRepository_);
}
void MockSupport::installComparator(const SimpleString& typeName, MockNamedValueComparator& comparator)
{
comparatorsAndCopiersRepository_.installComparator(typeName, comparator);
for (MockNamedValueListNode* p = data_.begin(); p; p = p->next())
if (getMockSupport(p)) getMockSupport(p)->installComparator(typeName, comparator);
}
void MockSupport::installCopier(const SimpleString& typeName, MockNamedValueCopier& copier)
{
comparatorsAndCopiersRepository_.installCopier(typeName, copier);
for (MockNamedValueListNode* p = data_.begin(); p; p = p->next())
if (getMockSupport(p)) getMockSupport(p)->installCopier(typeName, copier);
}
void MockSupport::installComparatorsAndCopiers(const MockNamedValueComparatorsAndCopiersRepository& repository)
{
comparatorsAndCopiersRepository_.installComparatorsAndCopiers(repository);
for (MockNamedValueListNode* p = data_.begin(); p; p = p->next())
if (getMockSupport(p)) getMockSupport(p)->installComparatorsAndCopiers(repository);
}
void MockSupport::removeAllComparatorsAndCopiers()
{
comparatorsAndCopiersRepository_.clear();
for (MockNamedValueListNode* p = data_.begin(); p; p = p->next())
if (getMockSupport(p)) getMockSupport(p)->removeAllComparatorsAndCopiers();
}
void MockSupport::clear()
{
delete lastActualFunctionCall_;
lastActualFunctionCall_ = NULLPTR;
tracing_ = false;
MockActualCallTrace::clearInstance();
expectations_.deleteAllExpectationsAndClearList();
ignoreOtherCalls_ = false;
enabled_ = true;
actualCallOrder_ = 0;
expectedCallOrder_ = 0;
strictOrdering_ = false;
for (MockNamedValueListNode* p = data_.begin(); p; p = p->next()) {
MockSupport* support = getMockSupport(p);
if (support) {
support->clear();
delete support;
}
}
data_.clear();
}
void MockSupport::strictOrder()
{
strictOrdering_ = true;
}
SimpleString MockSupport::appendScopeToName(const SimpleString& functionName)
{
if (mockName_.isEmpty()) return functionName;
return mockName_ + "::" + functionName;
}
MockExpectedCall& MockSupport::expectOneCall(const SimpleString& functionName)
{
return expectNCalls(1, functionName);
}
void MockSupport::expectNoCall(const SimpleString& functionName)
{
expectNCalls(0, functionName);
}
MockExpectedCall& MockSupport::expectNCalls(unsigned int amount, const SimpleString& functionName)
{
if (!enabled_) return MockIgnoredExpectedCall::instance();
countCheck();
MockCheckedExpectedCall* call = new MockCheckedExpectedCall(amount);
call->withName(appendScopeToName(functionName));
if (strictOrdering_) {
call->withCallOrder(expectedCallOrder_ + 1, expectedCallOrder_ + amount);
expectedCallOrder_ += amount;
}
expectations_.addExpectedCall(call);
return *call;
}
MockCheckedActualCall* MockSupport::createActualCall()
{
lastActualFunctionCall_ = new MockCheckedActualCall(++actualCallOrder_, activeReporter_, expectations_);
return lastActualFunctionCall_;
}
bool MockSupport::callIsIgnored(const SimpleString& functionName)
{
return ignoreOtherCalls_ && !expectations_.hasExpectationWithName(functionName);
}
MockActualCall& MockSupport::actualCall(const SimpleString& functionName)
{
const SimpleString scopeFunctionName = appendScopeToName(functionName);
if (lastActualFunctionCall_) {
lastActualFunctionCall_->checkExpectations();
delete lastActualFunctionCall_;
lastActualFunctionCall_ = NULLPTR;
}
if (!enabled_) return MockIgnoredActualCall::instance();
if (tracing_) return MockActualCallTrace::instance().withName(scopeFunctionName);
if (callIsIgnored(scopeFunctionName)) {
return MockIgnoredActualCall::instance();
}
MockCheckedActualCall* call = createActualCall();
call->withName(scopeFunctionName);
return *call;
}
void MockSupport::ignoreOtherCalls()
{
ignoreOtherCalls_ = true;
for (MockNamedValueListNode* p = data_.begin(); p; p = p->next())
if (getMockSupport(p)) getMockSupport(p)->ignoreOtherCalls();
}
void MockSupport::disable()
{
enabled_ = false;
for (MockNamedValueListNode* p = data_.begin(); p; p = p->next())
if (getMockSupport(p)) getMockSupport(p)->disable();
}
void MockSupport::enable()
{
enabled_ = true;
for (MockNamedValueListNode* p = data_.begin(); p; p = p->next())
if (getMockSupport(p)) getMockSupport(p)->enable();
}
void MockSupport::tracing(bool enabled)
{
tracing_ = enabled;
for (MockNamedValueListNode* p = data_.begin(); p; p = p->next())
if (getMockSupport(p)) getMockSupport(p)->tracing(enabled);
}
const char* MockSupport::getTraceOutput()
{
return MockActualCallTrace::instance().getTraceOutput();
}
bool MockSupport::expectedCallsLeft()
{
int callsLeft = expectations_.hasUnfulfilledExpectations();
for (MockNamedValueListNode* p = data_.begin(); p; p = p->next())
if (getMockSupport(p)) callsLeft += getMockSupport(p)->expectedCallsLeft();
return callsLeft != 0;
}
bool MockSupport::wasLastActualCallFulfilled()
{
if (lastActualFunctionCall_ && !lastActualFunctionCall_->isFulfilled())
return false;
for (MockNamedValueListNode* p = data_.begin(); p; p = p->next())
if (getMockSupport(p) && !getMockSupport(p)->wasLastActualCallFulfilled())
return false;
return true;
}
void MockSupport::failTestWithExpectedCallsNotFulfilled()
{
MockExpectedCallsList expectationsList;
expectationsList.addExpectations(expectations_);
for(MockNamedValueListNode *p = data_.begin();p;p = p->next())
if(getMockSupport(p))
expectationsList.addExpectations(getMockSupport(p)->expectations_);
MockExpectedCallsDidntHappenFailure failure(activeReporter_->getTestToFail(), expectationsList);
failTest(failure);
}
void MockSupport::failTestWithOutOfOrderCalls()
{
MockExpectedCallsList expectationsList;
expectationsList.addExpectations(expectations_);
for(MockNamedValueListNode *p = data_.begin();p;p = p->next())
if(getMockSupport(p))
expectationsList.addExpectations(getMockSupport(p)->expectations_);
MockCallOrderFailure failure(activeReporter_->getTestToFail(), expectationsList);
failTest(failure);
}
void MockSupport::failTest(MockFailure& failure)
{
clear();
activeReporter_->failTest(failure);
}
void MockSupport::countCheck()
{
UtestShell::getCurrent()->countCheck();
}
void MockSupport::checkExpectationsOfLastActualCall()
{
if(lastActualFunctionCall_)
lastActualFunctionCall_->checkExpectations();
for(MockNamedValueListNode *p = data_.begin();p;p = p->next())
if(getMockSupport(p) && getMockSupport(p)->lastActualFunctionCall_)
getMockSupport(p)->lastActualFunctionCall_->checkExpectations();
}
bool MockSupport::hasCallsOutOfOrder()
{
if (expectations_.hasCallsOutOfOrder())
{
return true;
}
for (MockNamedValueListNode* p = data_.begin(); p; p = p->next())
if (getMockSupport(p) && getMockSupport(p)->hasCallsOutOfOrder())
{
return true;
}
return false;
}
void MockSupport::checkExpectations()
{
checkExpectationsOfLastActualCall();
if (wasLastActualCallFulfilled() && expectedCallsLeft())
failTestWithExpectedCallsNotFulfilled();
if (hasCallsOutOfOrder())
failTestWithOutOfOrderCalls();
}
bool MockSupport::hasData(const SimpleString& name)
{
return data_.getValueByName(name) != NULLPTR;
}
MockNamedValue* MockSupport::retrieveDataFromStore(const SimpleString& name)
{
MockNamedValue* newData = data_.getValueByName(name);
if (newData == NULLPTR) {
newData = new MockNamedValue(name);
data_.add(newData);
}
return newData;
}
void MockSupport::setData(const SimpleString& name, bool value)
{
MockNamedValue* newData = retrieveDataFromStore(name);
newData->setValue(value);
}
void MockSupport::setData(const SimpleString& name, unsigned int value)
{
MockNamedValue* newData = retrieveDataFromStore(name);
newData->setValue(value);
}
void MockSupport::setData(const SimpleString& name, int value)
{
MockNamedValue* newData = retrieveDataFromStore(name);
newData->setValue(value);
}
void MockSupport::setData(const SimpleString& name, const char* value)
{
MockNamedValue* newData = retrieveDataFromStore(name);
newData->setValue(value);
}
void MockSupport::setData(const SimpleString& name, double value)
{
MockNamedValue* newData = retrieveDataFromStore(name);
newData->setValue(value);
}
void MockSupport::setData(const SimpleString& name, void* value)
{
MockNamedValue* newData = retrieveDataFromStore(name);
newData->setValue(value);
}
void MockSupport::setData(const SimpleString& name, const void* value)
{
MockNamedValue* newData = retrieveDataFromStore(name);
newData->setValue(value);
}
void MockSupport::setData(const SimpleString& name, void (*value)())
{
MockNamedValue* newData = retrieveDataFromStore(name);
newData->setValue(value);
}
void MockSupport::setDataObject(const SimpleString& name, const SimpleString& type, void* value)
{
MockNamedValue* newData = retrieveDataFromStore(name);
newData->setObjectPointer(type, value);
}
void MockSupport::setDataConstObject(const SimpleString& name, const SimpleString& type, const void* value)
{
MockNamedValue* newData = retrieveDataFromStore(name);
newData->setConstObjectPointer(type, value);
}
MockNamedValue MockSupport::getData(const SimpleString& name)
{
MockNamedValue* value = data_.getValueByName(name);
if (value == NULLPTR)
return MockNamedValue("");
return *value;
}
MockSupport* MockSupport::clone(const SimpleString& mockName)
{
MockSupport* newMock = new MockSupport(mockName);
newMock->setMockFailureStandardReporter(standardReporter_);
if (ignoreOtherCalls_) newMock->ignoreOtherCalls();
if (!enabled_) newMock->disable();
if (strictOrdering_) newMock->strictOrder();
newMock->tracing(tracing_);
newMock->installComparatorsAndCopiers(comparatorsAndCopiersRepository_);
return newMock;
}
MockSupport* MockSupport::getMockSupportScope(const SimpleString& name)
{
SimpleString mockingSupportName = MOCK_SUPPORT_SCOPE_PREFIX;
mockingSupportName += name;
if (hasData(mockingSupportName)) {
STRCMP_EQUAL("MockSupport", getData(mockingSupportName).getType().asCharString());
return (MockSupport*) getData(mockingSupportName).getObjectPointer();
}
MockSupport *newMock = clone(name);
setDataObject(mockingSupportName, "MockSupport", newMock);
return newMock;
}
MockSupport* MockSupport::getMockSupport(MockNamedValueListNode* node)
{
if (node->getType() == "MockSupport" && node->getName().contains(MOCK_SUPPORT_SCOPE_PREFIX))
return (MockSupport*) node->item()->getObjectPointer();
return NULLPTR;
}
MockNamedValue MockSupport::returnValue()
{
if (lastActualFunctionCall_) return lastActualFunctionCall_->returnValue();
return MockNamedValue("");
}
bool MockSupport::boolReturnValue()
{
return returnValue().getBoolValue();
}
unsigned int MockSupport::unsignedIntReturnValue()
{
return returnValue().getUnsignedIntValue();
}
int MockSupport::intReturnValue()
{
return returnValue().getIntValue();
}
const char * MockSupport::returnStringValueOrDefault(const char * defaultValue)
{
if (hasReturnValue()) {
return stringReturnValue();
}
return defaultValue;
}
double MockSupport::returnDoubleValueOrDefault(double defaultValue)
{
if (hasReturnValue()) {
return doubleReturnValue();
}
return defaultValue;
}
long int MockSupport::returnLongIntValueOrDefault(long int defaultValue)
{
if (hasReturnValue()) {
return longIntReturnValue();
}
return defaultValue;
}
bool MockSupport::returnBoolValueOrDefault(bool defaultValue)
{
if (hasReturnValue()) {
return boolReturnValue();
}
return defaultValue;
}
int MockSupport::returnIntValueOrDefault(int defaultValue)
{
if (hasReturnValue()) {
return intReturnValue();
}
return defaultValue;
}
unsigned int MockSupport::returnUnsignedIntValueOrDefault(unsigned int defaultValue)
{
if (hasReturnValue()) {
return unsignedIntReturnValue();
}
return defaultValue;
}
unsigned long int MockSupport::returnUnsignedLongIntValueOrDefault(unsigned long int defaultValue)
{
if (hasReturnValue()) {
return unsignedLongIntReturnValue();
}
return defaultValue;
}
long int MockSupport::longIntReturnValue()
{
return returnValue().getLongIntValue();
}
unsigned long int MockSupport::unsignedLongIntReturnValue()
{
return returnValue().getUnsignedLongIntValue();
}
#if CPPUTEST_USE_LONG_LONG
cpputest_longlong MockSupport::longLongIntReturnValue()
{
return returnValue().getLongLongIntValue();
}
cpputest_ulonglong MockSupport::unsignedLongLongIntReturnValue()
{
return returnValue().getUnsignedLongLongIntValue();
}
cpputest_longlong MockSupport::returnLongLongIntValueOrDefault(cpputest_longlong defaultValue)
{
if (hasReturnValue()) {
return longLongIntReturnValue();
}
return defaultValue;
}
cpputest_ulonglong MockSupport::returnUnsignedLongLongIntValueOrDefault(cpputest_ulonglong defaultValue)
{
if (hasReturnValue()) {
return unsignedLongLongIntReturnValue();
}
return defaultValue;
}
#else
cpputest_longlong MockSupport::longLongIntReturnValue()
{
FAIL("Long Long type is not supported");
cpputest_longlong ret = {};
return ret;
}
cpputest_ulonglong MockSupport::unsignedLongLongIntReturnValue()
{
FAIL("Unsigned Long Long type is not supported");
cpputest_ulonglong ret = {};
return ret;
}
cpputest_longlong MockSupport::returnLongLongIntValueOrDefault(cpputest_longlong defaultValue)
{
FAIL("Long Long type is not supported");
return defaultValue;
}
cpputest_ulonglong MockSupport::returnUnsignedLongLongIntValueOrDefault(cpputest_ulonglong defaultValue)
{
FAIL("Unsigned Long Long type is not supported");
return defaultValue;
}
#endif
const char* MockSupport::stringReturnValue()
{
return returnValue().getStringValue();
}
double MockSupport::doubleReturnValue()
{
return returnValue().getDoubleValue();
}
void * MockSupport::returnPointerValueOrDefault(void * defaultValue)
{
if (hasReturnValue()) {
return pointerReturnValue();
}
return defaultValue;
}
const void* MockSupport::returnConstPointerValueOrDefault(const void * defaultValue)
{
if (hasReturnValue()) {
return constPointerReturnValue();
}
return defaultValue;
}
void (*MockSupport::returnFunctionPointerValueOrDefault(void (*defaultValue)()))()
{
if (hasReturnValue()) {
return functionPointerReturnValue();
}
return defaultValue;
}
void* MockSupport::pointerReturnValue()
{
return returnValue().getPointerValue();
}
const void* MockSupport::constPointerReturnValue()
{
return returnValue().getConstPointerValue();
}
void (*MockSupport::functionPointerReturnValue())()
{
return returnValue().getFunctionPointerValue();
}
bool MockSupport::hasReturnValue()
{
if (lastActualFunctionCall_) return lastActualFunctionCall_->hasReturnValue();
return false;
}
| null |
39 | cpp | cpputest | MockSupportPlugin.cpp | src/CppUTestExt/MockSupportPlugin.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/TestHarness.h"
#include "CppUTestExt/MockSupport.h"
#include "CppUTestExt/MockSupportPlugin.h"
class MockSupportPluginReporter : public MockFailureReporter
{
UtestShell& test_;
TestResult& result_;
public:
MockSupportPluginReporter(UtestShell& test, TestResult& result)
: test_(test), result_(result)
{
}
virtual void failTest(const MockFailure& failure) CPPUTEST_OVERRIDE
{
result_.addFailure(failure);
}
virtual UtestShell* getTestToFail() CPPUTEST_OVERRIDE
{
return &test_;
}
};
MockSupportPlugin::MockSupportPlugin(const SimpleString& name)
: TestPlugin(name)
{
}
MockSupportPlugin::~MockSupportPlugin()
{
clear();
}
void MockSupportPlugin::clear()
{
repository_.clear();
}
void MockSupportPlugin::preTestAction(UtestShell&, TestResult&)
{
mock().installComparatorsAndCopiers(repository_);
}
void MockSupportPlugin::postTestAction(UtestShell& test, TestResult& result)
{
MockSupportPluginReporter reporter(test, result);
mock().setMockFailureStandardReporter(&reporter);
if (!test.hasFailed())
mock().checkExpectations();
mock().clear();
mock().setMockFailureStandardReporter(NULLPTR);
mock().removeAllComparatorsAndCopiers();
}
void MockSupportPlugin::installComparator(const SimpleString& name, MockNamedValueComparator& comparator)
{
repository_.installComparator(name, comparator);
}
void MockSupportPlugin::installCopier(const SimpleString& name, MockNamedValueCopier& copier)
{
repository_.installCopier(name, copier);
}
| null |
40 | cpp | cpputest | GTest.cpp | src/CppUTestExt/GTest.cpp | null |
#include "CppUTest/TestHarness.h"
#include "CppUTestExt/GTestSupport.h"
void CppuTestGTestIgnoreLeaksInTest()
{
IGNORE_ALL_LEAKS_IN_TEST();
}
| null |
41 | cpp | cpputest | OrderedTest.cpp | src/CppUTestExt/OrderedTest.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/TestHarness.h"
#include "CppUTest/TestRegistry.h"
#include "CppUTestExt/OrderedTest.h"
OrderedTestShell* OrderedTestShell::_orderedTestsHead = NULLPTR;
OrderedTestShell::OrderedTestShell() :
_nextOrderedTest(NULLPTR), _level(0)
{
}
OrderedTestShell::~OrderedTestShell()
{
}
int OrderedTestShell::getLevel()
{
return _level;
}
void OrderedTestShell::setLevel(int level)
{
_level = level;
}
void OrderedTestShell::setOrderedTestHead(OrderedTestShell* test)
{
_orderedTestsHead = test;
}
OrderedTestShell* OrderedTestShell::getOrderedTestHead()
{
return _orderedTestsHead;
}
bool OrderedTestShell::firstOrderedTest()
{
return (getOrderedTestHead() == NULLPTR);
}
OrderedTestShell* OrderedTestShell::addOrderedTest(OrderedTestShell* test)
{
UtestShell::addTest(test);
_nextOrderedTest = test;
return this;
}
void OrderedTestShell::addOrderedTestToHead(OrderedTestShell* test)
{
TestRegistry *reg = TestRegistry::getCurrentRegistry();
UtestShell* head = getOrderedTestHead();
if (NULLPTR == reg->getFirstTest() || head == reg->getFirstTest()) {
reg->addTest(test);
}
else {
reg->getTestWithNext(head)->addTest(test);
test->addTest(head);
}
test->_nextOrderedTest = getOrderedTestHead();
setOrderedTestHead(test);
}
OrderedTestShell* OrderedTestShell::getNextOrderedTest()
{
return _nextOrderedTest;
}
OrderedTestInstaller::OrderedTestInstaller(OrderedTestShell& test,
const char* groupName, const char* testName, const char* fileName,
size_t lineNumber, int level)
{
test.setTestName(testName);
test.setGroupName(groupName);
test.setFileName(fileName);
test.setLineNumber(lineNumber);
test.setLevel(level);
if (OrderedTestShell::firstOrderedTest()) OrderedTestShell::addOrderedTestToHead(&test);
else addOrderedTestInOrder(&test);
}
void OrderedTestInstaller::addOrderedTestInOrder(OrderedTestShell* test)
{
if (test->getLevel() < OrderedTestShell::getOrderedTestHead()->getLevel())
OrderedTestShell::addOrderedTestToHead(test);
else addOrderedTestInOrderNotAtHeadPosition(test);
}
void OrderedTestInstaller::addOrderedTestInOrderNotAtHeadPosition(
OrderedTestShell* test)
{
OrderedTestShell* current = OrderedTestShell::getOrderedTestHead();
while (current->getNextOrderedTest()) {
if (current->getNextOrderedTest()->getLevel() > test->getLevel()) {
test->addOrderedTest(current->getNextOrderedTest());
current->addOrderedTest(test);
return;
}
current = current->getNextOrderedTest();
}
test->addOrderedTest(current->getNextOrderedTest());
current->addOrderedTest(test);
}
OrderedTestInstaller::~OrderedTestInstaller()
{
}
| null |
42 | cpp | cpputest | MemoryReportAllocator.cpp | src/CppUTestExt/MemoryReportAllocator.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/TestHarness.h"
#include "CppUTestExt/MemoryReportAllocator.h"
#include "CppUTestExt/MemoryReportFormatter.h"
MemoryReportAllocator::MemoryReportAllocator() : result_(NULLPTR), realAllocator_(NULLPTR), formatter_(NULLPTR)
{
}
MemoryReportAllocator::~MemoryReportAllocator()
{
}
const char* MemoryReportAllocator::name() const
{
return "MemoryReporterAllocator";
}
const char* MemoryReportAllocator::alloc_name() const
{
return realAllocator_->alloc_name();
}
const char* MemoryReportAllocator::free_name() const
{
return realAllocator_->free_name();
}
void MemoryReportAllocator::setRealAllocator(TestMemoryAllocator* allocator)
{
realAllocator_ = allocator;
}
TestMemoryAllocator* MemoryReportAllocator::getRealAllocator()
{
return realAllocator_;
}
TestMemoryAllocator* MemoryReportAllocator::actualAllocator()
{
return realAllocator_->actualAllocator();
}
void MemoryReportAllocator::setTestResult(TestResult* result)
{
result_ = result;
}
void MemoryReportAllocator::setFormatter(MemoryReportFormatter* formatter)
{
formatter_ = formatter;
}
char* MemoryReportAllocator::alloc_memory(size_t size, const char* file, size_t line)
{
char* memory = realAllocator_->alloc_memory(size, file, line);
if (result_ && formatter_)
formatter_->report_alloc_memory(result_, this, size, memory, file, line);
return memory;
}
void MemoryReportAllocator::free_memory(char* memory, size_t size, const char* file, size_t line)
{
realAllocator_->free_memory(memory, size, file, line);
if (result_ && formatter_)
formatter_->report_free_memory(result_, this, memory, file, line);
}
| null |
43 | cpp | cpputest | CodeMemoryReportFormatter.cpp | src/CppUTestExt/CodeMemoryReportFormatter.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/TestHarness.h"
#include "CppUTestExt/CodeMemoryReportFormatter.h"
#include "CppUTestExt/MemoryReportAllocator.h"
#include "CppUTest/PlatformSpecificFunctions.h"
#define MAX_VARIABLE_NAME_LINE_PART 10
#define MAX_VARIABLE_NAME_FILE_PART 53
#define MAX_VARIABLE_NAME_SEPERATOR_PART 1
#define MAX_VARIABLE_NAME_LENGTH (MAX_VARIABLE_NAME_FILE_PART + MAX_VARIABLE_NAME_SEPERATOR_PART + MAX_VARIABLE_NAME_LINE_PART)
struct CodeReportingAllocationNode
{
char variableName_[MAX_VARIABLE_NAME_LENGTH + 1];
void* memory_;
CodeReportingAllocationNode* next_;
};
CodeMemoryReportFormatter::CodeMemoryReportFormatter(TestMemoryAllocator* internalAllocator)
: codeReportingList_(NULLPTR), internalAllocator_(internalAllocator)
{
}
CodeMemoryReportFormatter::~CodeMemoryReportFormatter()
{
clearReporting();
}
void CodeMemoryReportFormatter::clearReporting()
{
while (codeReportingList_) {
CodeReportingAllocationNode* oldNode = codeReportingList_;
codeReportingList_ = codeReportingList_->next_;
internalAllocator_->free_memory((char*) oldNode, 0, __FILE__, __LINE__);
}
}
void CodeMemoryReportFormatter::addNodeToList(const char* variableName, void* memory, CodeReportingAllocationNode* next)
{
CodeReportingAllocationNode* newNode = (CodeReportingAllocationNode*) (void*) internalAllocator_->alloc_memory(sizeof(CodeReportingAllocationNode), __FILE__, __LINE__);
newNode->memory_ = memory;
newNode->next_ = next;
SimpleString::StrNCpy(newNode->variableName_, variableName, MAX_VARIABLE_NAME_LENGTH);
codeReportingList_ = newNode;
}
CodeReportingAllocationNode* CodeMemoryReportFormatter::findNode(void* memory)
{
CodeReportingAllocationNode* current = codeReportingList_;
while (current && current->memory_ != memory) {
current = current->next_;
}
return current;
}
static SimpleString extractFileNameFromPath(const char* file)
{
const char* fileNameOnly = file + SimpleString::StrLen(file);
while (fileNameOnly != file && *fileNameOnly != '/')
fileNameOnly--;
if (*fileNameOnly == '/') fileNameOnly++;
return fileNameOnly;
}
SimpleString CodeMemoryReportFormatter::createVariableNameFromFileLineInfo(const char *file, size_t line)
{
SimpleString fileNameOnly = extractFileNameFromPath(file);
fileNameOnly.replace(".", "_");
for (int i = 1; i < 100; i++) {
SimpleString variableName = StringFromFormat("%s_%d_%d", fileNameOnly.asCharString(), (int) line, i);
if (!variableExists(variableName))
return variableName;
}
return "";
}
bool CodeMemoryReportFormatter::isNewAllocator(TestMemoryAllocator* allocator)
{
return SimpleString::StrCmp(allocator->alloc_name(), defaultNewAllocator()->alloc_name()) == 0 || SimpleString::StrCmp(allocator->alloc_name(), defaultNewArrayAllocator()->alloc_name()) == 0;
}
bool CodeMemoryReportFormatter::variableExists(const SimpleString& variableName)
{
CodeReportingAllocationNode* current = codeReportingList_;
while (current) {
if (variableName == current->variableName_)
return true;
current = current->next_;
}
return false;
}
SimpleString CodeMemoryReportFormatter::getAllocationString(TestMemoryAllocator* allocator, const SimpleString& variableName, size_t size)
{
if (isNewAllocator(allocator))
return StringFromFormat("char* %s = new char[%lu]; /* using %s */", variableName.asCharString(), (unsigned long) size, allocator->alloc_name());
else
return StringFromFormat("void* %s = malloc(%lu);", variableName.asCharString(), (unsigned long) size);
}
SimpleString CodeMemoryReportFormatter::getDeallocationString(TestMemoryAllocator* allocator, const SimpleString& variableName, const char* file, size_t line)
{
if (isNewAllocator(allocator))
return StringFromFormat("delete [] %s; /* using %s at %s:%d */", variableName.asCharString(), allocator->free_name(), file, (int) line);
else
return StringFromFormat("free(%s); /* at %s:%d */", variableName.asCharString(), file, (int) line);
}
void CodeMemoryReportFormatter::report_test_start(TestResult* result, UtestShell& test)
{
clearReporting();
result->print(StringFromFormat("*/\nTEST(%s_memoryReport, %s)\n{ /* at %s:%d */\n",
test.getGroup().asCharString(), test.getName().asCharString(), test.getFile().asCharString(), (int) test.getLineNumber()).asCharString());
}
void CodeMemoryReportFormatter::report_test_end(TestResult* result, UtestShell&)
{
result->print("}/*");
}
void CodeMemoryReportFormatter::report_testgroup_start(TestResult* result, UtestShell& test)
{
result->print(StringFromFormat("*/TEST_GROUP(%s_memoryReport)\n{\n};\n/*",
test.getGroup().asCharString()).asCharString());
}
void CodeMemoryReportFormatter::report_alloc_memory(TestResult* result, TestMemoryAllocator* allocator, size_t size, char* memory, const char* file, size_t line)
{
SimpleString variableName = createVariableNameFromFileLineInfo(file, line);
result->print(StringFromFormat("\t%s\n", getAllocationString(allocator, variableName, size).asCharString()).asCharString());
addNodeToList(variableName.asCharString(), memory, codeReportingList_);
}
void CodeMemoryReportFormatter::report_free_memory(TestResult* result, TestMemoryAllocator* allocator, char* memory, const char* file, size_t line)
{
SimpleString variableName;
CodeReportingAllocationNode* node = findNode(memory);
if (memory == NULLPTR) variableName = "NULL";
else variableName = node->variableName_;
result->print(StringFromFormat("\t%s\n", getDeallocationString(allocator, variableName, file, line).asCharString()).asCharString());
}
| null |
44 | cpp | cpputest | IEEE754ExceptionsPlugin.cpp | src/CppUTestExt/IEEE754ExceptionsPlugin.cpp | null | /*
* Copyright (c) 2015, Michael Feathers, James Grenning, Bas Vodde
* and Arnd R. Strube. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/TestHarness.h"
#include "CppUTestExt/IEEE754ExceptionsPlugin.h"
#if CPPUTEST_HAVE_FENV
extern "C" {
#include <fenv.h>
}
#define IEEE754_CHECK_CLEAR(test, result, flag) ieee754Check(test, result, flag, #flag)
bool IEEE754ExceptionsPlugin::inexactDisabled_ = true;
IEEE754ExceptionsPlugin::IEEE754ExceptionsPlugin(const SimpleString& name)
: TestPlugin(name)
{
}
void IEEE754ExceptionsPlugin::preTestAction(UtestShell&, TestResult&)
{
CHECK(!feclearexcept(FE_ALL_EXCEPT));
}
void IEEE754ExceptionsPlugin::postTestAction(UtestShell& test, TestResult& result)
{
if(!test.hasFailed()) {
IEEE754_CHECK_CLEAR(test, result, FE_DIVBYZERO);
IEEE754_CHECK_CLEAR(test, result, FE_OVERFLOW);
IEEE754_CHECK_CLEAR(test, result, FE_UNDERFLOW);
IEEE754_CHECK_CLEAR(test, result, FE_INVALID); // LCOV_EXCL_LINE (not all platforms support this)
IEEE754_CHECK_CLEAR(test, result, FE_INEXACT);
}
}
void IEEE754ExceptionsPlugin::disableInexact()
{
inexactDisabled_ = true;
}
void IEEE754ExceptionsPlugin::enableInexact()
{
inexactDisabled_ = false;
}
bool IEEE754ExceptionsPlugin::checkIeee754OverflowExceptionFlag()
{
return fetestexcept(FE_OVERFLOW) != 0;
}
bool IEEE754ExceptionsPlugin::checkIeee754UnderflowExceptionFlag()
{
return fetestexcept(FE_UNDERFLOW) != 0;
}
bool IEEE754ExceptionsPlugin::checkIeee754InexactExceptionFlag()
{
return fetestexcept(FE_INEXACT) != 0;
}
bool IEEE754ExceptionsPlugin::checkIeee754DivByZeroExceptionFlag()
{
return fetestexcept(FE_DIVBYZERO) != 0;
}
void IEEE754ExceptionsPlugin::ieee754Check(UtestShell& test, TestResult& result, int flag, const char* text)
{
result.countCheck();
if(inexactDisabled_) CHECK(!feclearexcept(FE_INEXACT));
if(fetestexcept(flag)) {
CHECK(!feclearexcept(FE_ALL_EXCEPT));
CheckFailure failure(&test, __FILE__, __LINE__, "IEEE754_CHECK_CLEAR", text);
result.addFailure(failure);
}
}
#else
bool IEEE754ExceptionsPlugin::inexactDisabled_ = true;
IEEE754ExceptionsPlugin::IEEE754ExceptionsPlugin(const SimpleString& name)
: TestPlugin(name)
{
}
void IEEE754ExceptionsPlugin::preTestAction(UtestShell&, TestResult&)
{
}
void IEEE754ExceptionsPlugin::postTestAction(UtestShell&, TestResult&)
{
}
void IEEE754ExceptionsPlugin::disableInexact()
{
}
void IEEE754ExceptionsPlugin::enableInexact()
{
}
bool IEEE754ExceptionsPlugin::checkIeee754OverflowExceptionFlag()
{
return false;
}
bool IEEE754ExceptionsPlugin::checkIeee754UnderflowExceptionFlag()
{
return false;
}
bool IEEE754ExceptionsPlugin::checkIeee754InexactExceptionFlag()
{
return false;
}
bool IEEE754ExceptionsPlugin::checkIeee754DivByZeroExceptionFlag()
{
return false;
}
void IEEE754ExceptionsPlugin::ieee754Check(UtestShell&, TestResult&, int, const char*)
{
}
#endif
| null |
45 | cpp | cpputest | MockExpectedCall.cpp | src/CppUTestExt/MockExpectedCall.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/TestHarness.h"
#include "CppUTestExt/MockCheckedExpectedCall.h"
MockExpectedCall::MockExpectedCall()
{
}
MockExpectedCall::~MockExpectedCall()
{
}
SimpleString StringFrom(const MockNamedValue& parameter)
{
return parameter.toString();
}
void MockCheckedExpectedCall::setName(const SimpleString& name)
{
functionName_ = name;
}
SimpleString MockCheckedExpectedCall::getName() const
{
return functionName_;
}
MockCheckedExpectedCall::MockCheckedExpectedCall()
: ignoreOtherParameters_(false), isActualCallMatchFinalized_(false),
initialExpectedCallOrder_(NO_EXPECTED_CALL_ORDER), finalExpectedCallOrder_(NO_EXPECTED_CALL_ORDER),
outOfOrder_(false), returnValue_(""), objectPtr_(NULLPTR), isSpecificObjectExpected_(false), wasPassedToObject_(true),
actualCalls_(0), expectedCalls_(1)
{
inputParameters_ = new MockNamedValueList();
outputParameters_ = new MockNamedValueList();
}
MockCheckedExpectedCall::MockCheckedExpectedCall(unsigned int numCalls)
: ignoreOtherParameters_(false), isActualCallMatchFinalized_(false),
initialExpectedCallOrder_(NO_EXPECTED_CALL_ORDER), finalExpectedCallOrder_(NO_EXPECTED_CALL_ORDER),
outOfOrder_(false), returnValue_(""), objectPtr_(NULLPTR), isSpecificObjectExpected_(false), wasPassedToObject_(true),
actualCalls_(0), expectedCalls_(numCalls)
{
inputParameters_ = new MockNamedValueList();
outputParameters_ = new MockNamedValueList();
}
MockCheckedExpectedCall::~MockCheckedExpectedCall()
{
inputParameters_->clear();
delete inputParameters_;
outputParameters_->clear();
delete outputParameters_;
}
MockExpectedCall& MockCheckedExpectedCall::withName(const SimpleString& name)
{
setName(name);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::withBoolParameter(const SimpleString& name, bool value)
{
MockNamedValue* newParameter = new MockExpectedFunctionParameter(name);
inputParameters_->add(newParameter);
newParameter->setValue(value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::withUnsignedIntParameter(const SimpleString& name, unsigned int value)
{
MockNamedValue* newParameter = new MockExpectedFunctionParameter(name);
inputParameters_->add(newParameter);
newParameter->setValue(value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::withIntParameter(const SimpleString& name, int value)
{
MockNamedValue* newParameter = new MockExpectedFunctionParameter(name);
inputParameters_->add(newParameter);
newParameter->setValue(value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::withLongIntParameter(const SimpleString& name, long int value)
{
MockNamedValue* newParameter = new MockExpectedFunctionParameter(name);
inputParameters_->add(newParameter);
newParameter->setValue(value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::withUnsignedLongIntParameter(const SimpleString& name, unsigned long int value)
{
MockNamedValue* newParameter = new MockExpectedFunctionParameter(name);
inputParameters_->add(newParameter);
newParameter->setValue(value);
return *this;
}
#if CPPUTEST_USE_LONG_LONG
MockExpectedCall& MockCheckedExpectedCall::withLongLongIntParameter(const SimpleString& name, cpputest_longlong value)
{
MockNamedValue* newParameter = new MockExpectedFunctionParameter(name);
inputParameters_->add(newParameter);
newParameter->setValue(value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::withUnsignedLongLongIntParameter(const SimpleString& name, cpputest_ulonglong value)
{
MockNamedValue* newParameter = new MockExpectedFunctionParameter(name);
inputParameters_->add(newParameter);
newParameter->setValue(value);
return *this;
}
#else
MockExpectedCall& MockCheckedExpectedCall::withLongLongIntParameter(const SimpleString&, cpputest_longlong)
{
FAIL("Long Long type is not supported");
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::withUnsignedLongLongIntParameter(const SimpleString&, cpputest_ulonglong)
{
FAIL("Unsigned Long Long type is not supported");
return *this;
}
#endif
MockExpectedCall& MockCheckedExpectedCall::withDoubleParameter(const SimpleString& name, double value)
{
MockNamedValue* newParameter = new MockExpectedFunctionParameter(name);
inputParameters_->add(newParameter);
newParameter->setValue(value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::withDoubleParameter(const SimpleString& name, double value, double tolerance)
{
MockNamedValue* newParameter = new MockExpectedFunctionParameter(name);
inputParameters_->add(newParameter);
newParameter->setValue(value, tolerance);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::withStringParameter(const SimpleString& name, const char* value)
{
MockNamedValue* newParameter = new MockExpectedFunctionParameter(name);
inputParameters_->add(newParameter);
newParameter->setValue(value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::withPointerParameter(const SimpleString& name, void* value)
{
MockNamedValue* newParameter = new MockExpectedFunctionParameter(name);
inputParameters_->add(newParameter);
newParameter->setValue(value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::withConstPointerParameter(const SimpleString& name, const void* value)
{
MockNamedValue* newParameter = new MockExpectedFunctionParameter(name);
inputParameters_->add(newParameter);
newParameter->setValue(value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::withFunctionPointerParameter(const SimpleString& name, void (*value)())
{
MockNamedValue* newParameter = new MockExpectedFunctionParameter(name);
inputParameters_->add(newParameter);
newParameter->setValue(value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::withMemoryBufferParameter(const SimpleString& name, const unsigned char* value, size_t size)
{
MockNamedValue* newParameter = new MockExpectedFunctionParameter(name);
inputParameters_->add(newParameter);
newParameter->setMemoryBuffer(value, size);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::withParameterOfType(const SimpleString& type, const SimpleString& name, const void* value)
{
MockNamedValue* newParameter = new MockExpectedFunctionParameter(name);
inputParameters_->add(newParameter);
newParameter->setConstObjectPointer(type, value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::withOutputParameterReturning(const SimpleString& name, const void* value, size_t size)
{
MockNamedValue* newParameter = new MockExpectedFunctionParameter(name);
outputParameters_->add(newParameter);
newParameter->setValue(value);
newParameter->setSize(size);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::withOutputParameterOfTypeReturning(const SimpleString& type, const SimpleString& name, const void* value)
{
MockNamedValue* newParameter = new MockExpectedFunctionParameter(name);
outputParameters_->add(newParameter);
newParameter->setConstObjectPointer(type, value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::withUnmodifiedOutputParameter(const SimpleString& name)
{
return withOutputParameterReturning(name, NULLPTR, 0);
}
SimpleString MockCheckedExpectedCall::getInputParameterType(const SimpleString& name)
{
MockNamedValue * p = inputParameters_->getValueByName(name);
return (p) ? p->getType() : StringFrom("");
}
bool MockCheckedExpectedCall::hasInputParameterWithName(const SimpleString& name)
{
MockNamedValue * p = inputParameters_->getValueByName(name);
return p != NULLPTR;
}
bool MockCheckedExpectedCall::hasOutputParameterWithName(const SimpleString& name)
{
MockNamedValue * p = outputParameters_->getValueByName(name);
return p != NULLPTR;
}
MockNamedValue MockCheckedExpectedCall::getInputParameter(const SimpleString& name)
{
MockNamedValue * p = inputParameters_->getValueByName(name);
return (p) ? *p : MockNamedValue("");
}
MockNamedValue MockCheckedExpectedCall::getOutputParameter(const SimpleString& name)
{
MockNamedValue * p = outputParameters_->getValueByName(name);
return (p) ? *p : MockNamedValue("");
}
bool MockCheckedExpectedCall::areParametersMatchingActualCall()
{
MockNamedValueListNode* p;
for (p = inputParameters_->begin(); p; p = p->next())
if (! item(p)->isMatchingActualCall())
return false;
for (p = outputParameters_->begin(); p; p = p->next())
if (! item(p)->isMatchingActualCall())
return false;
return true;
}
MockExpectedCall& MockCheckedExpectedCall::ignoreOtherParameters()
{
ignoreOtherParameters_ = true;
return *this;
}
bool MockCheckedExpectedCall::isFulfilled()
{
return (actualCalls_ == expectedCalls_);
}
bool MockCheckedExpectedCall::canMatchActualCalls()
{
return (actualCalls_ < expectedCalls_);
}
bool MockCheckedExpectedCall::isMatchingActualCallAndFinalized()
{
return isMatchingActualCall() && (!ignoreOtherParameters_ || isActualCallMatchFinalized_);
}
bool MockCheckedExpectedCall::isMatchingActualCall()
{
return areParametersMatchingActualCall() && wasPassedToObject_;
}
void MockCheckedExpectedCall::callWasMade(unsigned int callOrder)
{
actualCalls_++;
if ( (initialExpectedCallOrder_ != NO_EXPECTED_CALL_ORDER) &&
((callOrder < initialExpectedCallOrder_) || (callOrder > finalExpectedCallOrder_)) ) {
outOfOrder_ = true;
}
resetActualCallMatchingState();
}
void MockCheckedExpectedCall::finalizeActualCallMatch()
{
isActualCallMatchFinalized_ = true;
}
void MockCheckedExpectedCall::wasPassedToObject()
{
wasPassedToObject_ = true;
}
void MockCheckedExpectedCall::resetActualCallMatchingState()
{
wasPassedToObject_ = !isSpecificObjectExpected_;
isActualCallMatchFinalized_ = false;
MockNamedValueListNode* p;
for (p = inputParameters_->begin(); p; p = p->next())
item(p)->setMatchesActualCall(false);
for (p = outputParameters_->begin(); p; p = p->next())
item(p)->setMatchesActualCall(false);
}
void MockCheckedExpectedCall::inputParameterWasPassed(const SimpleString& name)
{
for (MockNamedValueListNode* p = inputParameters_->begin(); p; p = p->next()) {
if (p->getName() == name)
item(p)->setMatchesActualCall(true);
}
}
void MockCheckedExpectedCall::outputParameterWasPassed(const SimpleString& name)
{
for (MockNamedValueListNode* p = outputParameters_->begin(); p; p = p->next()) {
if (p->getName() == name)
item(p)->setMatchesActualCall(true);
}
}
SimpleString MockCheckedExpectedCall::getInputParameterValueString(const SimpleString& name)
{
MockNamedValue * p = inputParameters_->getValueByName(name);
return (p) ? StringFrom(*p) : StringFrom("failed");
}
bool MockCheckedExpectedCall::hasInputParameter(const MockNamedValue& parameter)
{
MockNamedValue * p = inputParameters_->getValueByName(parameter.getName());
return (p) ? p->equals(parameter) : ignoreOtherParameters_;
}
bool MockCheckedExpectedCall::hasOutputParameter(const MockNamedValue& parameter)
{
MockNamedValue * p = outputParameters_->getValueByName(parameter.getName());
return (p) ? p->compatibleForCopying(parameter) : ignoreOtherParameters_;
}
SimpleString MockCheckedExpectedCall::callToString()
{
SimpleString str;
if (isSpecificObjectExpected_)
str = StringFromFormat("(object address: %p)::", objectPtr_);
str += getName();
str += " -> ";
if (initialExpectedCallOrder_ != NO_EXPECTED_CALL_ORDER) {
if (initialExpectedCallOrder_ == finalExpectedCallOrder_) {
str += StringFromFormat("expected call order: <%u> -> ", initialExpectedCallOrder_);
} else {
str += StringFromFormat("expected calls order: <%u..%u> -> ", initialExpectedCallOrder_, finalExpectedCallOrder_);
}
}
if (inputParameters_->begin() == NULLPTR && outputParameters_->begin() == NULLPTR) {
str += (ignoreOtherParameters_) ? "all parameters ignored" : "no parameters";
} else {
MockNamedValueListNode* p;
for (p = inputParameters_->begin(); p; p = p->next()) {
str += StringFromFormat("%s %s: <%s>", p->getType().asCharString(), p->getName().asCharString(), getInputParameterValueString(p->getName()).asCharString());
if (p->next()) str += ", ";
}
if (inputParameters_->begin() && outputParameters_->begin())
{
str += ", ";
}
for (p = outputParameters_->begin(); p; p = p->next()) {
str += StringFromFormat("%s %s: <output>", p->getType().asCharString(), p->getName().asCharString());
if (p->next()) str += ", ";
}
if (ignoreOtherParameters_)
str += ", other parameters are ignored";
}
str += StringFromFormat(" (expected %d call%s, called %d time%s)",
expectedCalls_, (expectedCalls_ == 1) ? "" : "s", actualCalls_, (actualCalls_ == 1) ? "" : "s" );
return str;
}
SimpleString MockCheckedExpectedCall::missingParametersToString()
{
SimpleString str;
MockNamedValueListNode* p;
for (p = inputParameters_->begin(); p; p = p->next()) {
if (! item(p)->isMatchingActualCall()) {
if (str != "") str += ", ";
str += StringFromFormat("%s %s", p->getType().asCharString(), p->getName().asCharString());
}
}
for (p = outputParameters_->begin(); p; p = p->next()) {
if (! item(p)->isMatchingActualCall()) {
if (str != "") str += ", ";
str += StringFromFormat("%s %s", p->getType().asCharString(), p->getName().asCharString());
}
}
return str;
}
bool MockCheckedExpectedCall::relatesTo(const SimpleString& functionName)
{
return functionName == getName();
}
bool MockCheckedExpectedCall::relatesToObject(const void* objectPtr) const
{
return (!isSpecificObjectExpected_) || (objectPtr_ == objectPtr);
}
MockCheckedExpectedCall::MockExpectedFunctionParameter* MockCheckedExpectedCall::item(MockNamedValueListNode* node)
{
return (MockExpectedFunctionParameter*) node->item();
}
MockCheckedExpectedCall::MockExpectedFunctionParameter::MockExpectedFunctionParameter(const SimpleString& name)
: MockNamedValue(name), matchesActualCall_(false)
{
}
void MockCheckedExpectedCall::MockExpectedFunctionParameter::setMatchesActualCall(bool b)
{
matchesActualCall_ = b;
}
bool MockCheckedExpectedCall::MockExpectedFunctionParameter::isMatchingActualCall() const
{
return matchesActualCall_;
}
MockExpectedCall& MockCheckedExpectedCall::andReturnValue(bool value)
{
returnValue_.setName("returnValue");
returnValue_.setValue(value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::andReturnValue(unsigned int value)
{
returnValue_.setName("returnValue");
returnValue_.setValue(value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::andReturnValue(int value)
{
returnValue_.setName("returnValue");
returnValue_.setValue(value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::andReturnValue(long int value)
{
returnValue_.setName("returnValue");
returnValue_.setValue(value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::andReturnValue(unsigned long int value)
{
returnValue_.setName("returnValue");
returnValue_.setValue(value);
return *this;
}
#if CPPUTEST_USE_LONG_LONG
MockExpectedCall& MockCheckedExpectedCall::andReturnValue(cpputest_longlong value)
{
returnValue_.setName("returnValue");
returnValue_.setValue(value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::andReturnValue(cpputest_ulonglong value)
{
returnValue_.setName("returnValue");
returnValue_.setValue(value);
return *this;
}
#else
MockExpectedCall& MockCheckedExpectedCall::andReturnValue(cpputest_longlong)
{
FAIL("Long Long type is not supported");
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::andReturnValue(cpputest_ulonglong)
{
FAIL("Unsigned Long Long type is not supported");
return *this;
}
#endif
MockExpectedCall& MockCheckedExpectedCall::andReturnValue(const char* value)
{
returnValue_.setName("returnValue");
returnValue_.setValue(value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::andReturnValue(double value)
{
returnValue_.setName("returnValue");
returnValue_.setValue(value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::andReturnValue(void* value)
{
returnValue_.setName("returnValue");
returnValue_.setValue(value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::andReturnValue(const void* value)
{
returnValue_.setName("returnValue");
returnValue_.setValue(value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::andReturnValue(void (*value)())
{
returnValue_.setName("returnValue");
returnValue_.setValue(value);
return *this;
}
MockExpectedCall& MockCheckedExpectedCall::onObject(void* objectPtr)
{
isSpecificObjectExpected_ = true;
wasPassedToObject_ = false;
objectPtr_ = objectPtr;
return *this;
}
MockNamedValue MockCheckedExpectedCall::returnValue()
{
return returnValue_;
}
MockExpectedCall& MockCheckedExpectedCall::withCallOrder(unsigned int initialCallOrder, unsigned int finalCallOrder)
{
initialExpectedCallOrder_ = initialCallOrder;
finalExpectedCallOrder_ = finalCallOrder;
return *this;
}
bool MockCheckedExpectedCall::isOutOfOrder() const
{
return outOfOrder_;
}
unsigned int MockCheckedExpectedCall::getActualCallsFulfilled() const
{
return actualCalls_;
}
MockExpectedCall& MockIgnoredExpectedCall::instance()
{
static MockIgnoredExpectedCall call;
return call;
}
| null |
46 | cpp | cpputest | CommandLineTestRunner.cpp | src/CppUTest/CommandLineTestRunner.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/TestHarness.h"
#include "CppUTest/CommandLineTestRunner.h"
#include "CppUTest/TestOutput.h"
#include "CppUTest/JUnitTestOutput.h"
#include "CppUTest/TeamCityTestOutput.h"
#include "CppUTest/TestRegistry.h"
int CommandLineTestRunner::RunAllTests(int ac, char** av)
{
return RunAllTests(ac, (const char *const *) av);
}
int CommandLineTestRunner::RunAllTests(int ac, const char *const *av)
{
int result = 0;
ConsoleTestOutput backupOutput;
MemoryLeakWarningPlugin memLeakWarn(DEF_PLUGIN_MEM_LEAK);
memLeakWarn.destroyGlobalDetectorAndTurnOffMemoryLeakDetectionInDestructor(true);
TestRegistry::getCurrentRegistry()->installPlugin(&memLeakWarn);
{
CommandLineTestRunner runner(ac, av, TestRegistry::getCurrentRegistry());
result = runner.runAllTestsMain();
}
if (result == 0) {
backupOutput << memLeakWarn.FinalReport(0);
}
TestRegistry::getCurrentRegistry()->removePluginByName(DEF_PLUGIN_MEM_LEAK);
return result;
}
CommandLineTestRunner::CommandLineTestRunner(int ac, const char *const *av, TestRegistry* registry) :
output_(NULLPTR), arguments_(NULLPTR), registry_(registry)
{
arguments_ = new CommandLineArguments(ac, av);
}
CommandLineTestRunner::~CommandLineTestRunner()
{
delete arguments_;
delete output_;
}
int CommandLineTestRunner::runAllTestsMain()
{
int testResult = 1;
SetPointerPlugin pPlugin(DEF_PLUGIN_SET_POINTER);
registry_->installPlugin(&pPlugin);
if (parseArguments(registry_->getFirstPlugin()))
testResult = runAllTests();
registry_->removePluginByName(DEF_PLUGIN_SET_POINTER);
return testResult;
}
void CommandLineTestRunner::initializeTestRun()
{
registry_->setGroupFilters(arguments_->getGroupFilters());
registry_->setNameFilters(arguments_->getNameFilters());
if (arguments_->isVerbose()) output_->verbose(TestOutput::level_verbose);
if (arguments_->isVeryVerbose()) output_->verbose(TestOutput::level_veryVerbose);
if (arguments_->isColor()) output_->color();
if (arguments_->runTestsInSeperateProcess()) registry_->setRunTestsInSeperateProcess();
if (arguments_->isRunIgnored()) registry_->setRunIgnored();
if (arguments_->isCrashingOnFail()) UtestShell::setCrashOnFail();
UtestShell::setRethrowExceptions( arguments_->isRethrowingExceptions() );
}
int CommandLineTestRunner::runAllTests()
{
initializeTestRun();
size_t loopCount = 0;
size_t failedTestCount = 0;
size_t failedExecutionCount = 0;
size_t repeatCount = arguments_->getRepeatCount();
if (arguments_->isListingTestGroupNames())
{
TestResult tr(*output_);
registry_->listTestGroupNames(tr);
return 0;
}
if (arguments_->isListingTestGroupAndCaseNames())
{
TestResult tr(*output_);
registry_->listTestGroupAndCaseNames(tr);
return 0;
}
if (arguments_->isListingTestLocations())
{
TestResult tr(*output_);
registry_->listTestLocations(tr);
return 0;
}
if (arguments_->isReversing())
registry_->reverseTests();
if (arguments_->isShuffling())
{
output_->print("Test order shuffling enabled with seed: ");
output_->print(arguments_->getShuffleSeed());
output_->print("\n");
}
while (loopCount++ < repeatCount) {
if (arguments_->isShuffling())
registry_->shuffleTests(arguments_->getShuffleSeed());
output_->printTestRun(loopCount, repeatCount);
TestResult tr(*output_);
registry_->runAllTests(tr);
failedTestCount += tr.getFailureCount();
if (tr.isFailure()) {
failedExecutionCount++;
}
}
return (int) (failedTestCount != 0 ? failedTestCount : failedExecutionCount);
}
TestOutput* CommandLineTestRunner::createTeamCityOutput()
{
return new TeamCityTestOutput;
}
TestOutput* CommandLineTestRunner::createJUnitOutput(const SimpleString& packageName)
{
JUnitTestOutput* junitOutput = new JUnitTestOutput;
if (junitOutput != NULLPTR) {
junitOutput->setPackageName(packageName);
}
return junitOutput;
}
TestOutput* CommandLineTestRunner::createConsoleOutput()
{
return new ConsoleTestOutput;
}
TestOutput* CommandLineTestRunner::createCompositeOutput(TestOutput* outputOne, TestOutput* outputTwo)
{
CompositeTestOutput* composite = new CompositeTestOutput;
composite->setOutputOne(outputOne);
composite->setOutputTwo(outputTwo);
return composite;
}
bool CommandLineTestRunner::parseArguments(TestPlugin* plugin)
{
if (!arguments_->parse(plugin)) {
output_ = createConsoleOutput();
output_->print((arguments_->needHelp()) ? arguments_->help() : arguments_->usage());
return false;
}
if (arguments_->isJUnitOutput()) {
output_= createJUnitOutput(arguments_->getPackageName());
if (arguments_->isVerbose() || arguments_->isVeryVerbose())
output_ = createCompositeOutput(output_, createConsoleOutput());
} else if (arguments_->isTeamCityOutput()) {
output_ = createTeamCityOutput();
} else
output_ = createConsoleOutput();
return true;
}
| null |
47 | cpp | cpputest | TestTestingFixture.cpp | src/CppUTest/TestTestingFixture.cpp | null | /*
* Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "CppUTest/TestHarness.h"
#include "CppUTest/TestTestingFixture.h"
bool TestTestingFixture::lineOfCodeExecutedAfterCheck = false;
TestTestingFixture::TestTestingFixture()
{
output_ = new StringBufferTestOutput();
result_ = new TestResult(*output_);
genTest_ = new ExecFunctionTestShell();
registry_ = new TestRegistry();
ownsExecFunction_ = false;
registry_->setCurrentRegistry(registry_);
registry_->addTest(genTest_);
lineOfCodeExecutedAfterCheck = false;
}
void TestTestingFixture::flushOutputAndResetResult()
{
output_->flush();
delete result_;
result_ = new TestResult(*output_);
}
TestTestingFixture::~TestTestingFixture()
{
registry_->setCurrentRegistry(NULLPTR);
clearExecFunction();
delete registry_;
delete result_;
delete output_;
delete genTest_;
}
void TestTestingFixture::clearExecFunction()
{
if (genTest_->testFunction_ && ownsExecFunction_)
delete genTest_->testFunction_;
}
void TestTestingFixture::addTest(UtestShell * test)
{
registry_->addTest(test);
}
void TestTestingFixture::setTestFunction(void(*testFunction)())
{
clearExecFunction();
genTest_->testFunction_ = new ExecFunctionWithoutParameters(testFunction);
ownsExecFunction_ = true;
}
void TestTestingFixture::setTestFunction(ExecFunction* testFunction)
{
clearExecFunction();
genTest_->testFunction_ = testFunction;
ownsExecFunction_ = false;
}
void TestTestingFixture::setSetup(void(*setupFunction)())
{
genTest_->setup_ = setupFunction;
}
void TestTestingFixture::setTeardown(void(*teardownFunction)())
{
genTest_->teardown_ = teardownFunction;
}
void TestTestingFixture::installPlugin(TestPlugin* plugin)
{
registry_->installPlugin(plugin);
}
void TestTestingFixture::setRunTestsInSeperateProcess()
{
registry_->setRunTestsInSeperateProcess();
}
void TestTestingFixture::setOutputVerbose()
{
output_->verbose(TestOutput::level_verbose);
}
void TestTestingFixture::runTestWithMethod(void(*method)())
{
setTestFunction(method);
runAllTests();
}
void TestTestingFixture::runAllTests()
{
registry_->runAllTests(*result_);
}
size_t TestTestingFixture::getFailureCount()
{
return result_->getFailureCount();
}
size_t TestTestingFixture::getCheckCount()
{
return result_->getCheckCount();
}
size_t TestTestingFixture::getTestCount()
{
return result_->getTestCount();
}
size_t TestTestingFixture::getIgnoreCount()
{
return result_->getIgnoredCount();
}
TestRegistry* TestTestingFixture::getRegistry()
{
return registry_;
}
bool TestTestingFixture::hasTestFailed()
{
return genTest_->hasFailed();
}
void TestTestingFixture::assertPrintContains(const SimpleString& contains)
{
STRCMP_CONTAINS(contains.asCharString(), getOutput().asCharString());
}
void TestTestingFixture::assertPrintContainsNot(const SimpleString& contains)
{
CHECK(! getOutput().contains(contains));
}
const SimpleString& TestTestingFixture::getOutput()
{
return output_->getOutput();
}
size_t TestTestingFixture::getRunCount()
{
return result_->getRunCount();
}
void TestTestingFixture::lineExecutedAfterCheck()
{
lineOfCodeExecutedAfterCheck = true;
}
void TestTestingFixture::checkTestFailsWithProperTestLocation(const char* text, const char* file, size_t line)
{
if (getFailureCount() != 1)
FAIL_LOCATION(StringFromFormat("Expected one test failure, but got %d amount of test failures", (int) getFailureCount()).asCharString(), file, line);
STRCMP_CONTAINS_LOCATION(text, output_->getOutput().asCharString(), "", file, line);
if (lineOfCodeExecutedAfterCheck)
FAIL_LOCATION("The test should jump/throw on failure and not execute the next line. However, the next line was executed.", file, line);
}
| null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.