blob: 0e8e32667b821c6f31fa30f18ba4803778aa1082 [file] [log] [blame]
// Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#if defined(USE_OPENGLES)
#include "GLES2/gl2.h"
#elif defined(USE_OPENGL)
#include "GL/gl.h"
#include <signal.h>
#include <algorithm>
#include <functional>
#include <limits>
#include <map>
#include <string>
#include <vector>
extern double g_initial_temperature;
void SetBasePathFromArgv0(const char* argv0, const char* relative);
void* MmapFile(const char* name, size_t* length);
// Returns temperature of system before testing started. It is used as a
// reference for keeping the machine cool.
const double GetInitialMachineTemperature();
// For thermal monitoring of system.
double GetMachineTemperature();
// Wait for machine to cool with temperature in Celsius and timeout in seconds.
// Returns the time spent waiting and sets the last observed temperature.
double WaitForCoolMachine(double cold_temperature,
double timeout,
double* temperature);
bool check_dir_existence(const char* file_path);
bool check_file_existence(const char* file_path, struct stat* buffer);
// SplitString by delimiter.
std::vector<std::string> SplitString(std::string& input,
std::string delimiter,
bool trim_space);
template <typename INT>
std::string IntToString(INT value) {
// log10(2) ~= 0.3 bytes needed per bit or per byte log10(2**8) ~= 2.4.
// So round up to allocate 3 output characters per byte, plus 1 for '-'.
const size_t kOutputBufSize =
3 * sizeof(INT) + std::numeric_limits<INT>::is_signed;
// Create the string in a temporary buffer, write it back to front, and
// then return the substr of what we ended up using.
using CHR = typename std::string::value_type;
CHR outbuf[kOutputBufSize];
// The ValueOrDie call below can never fail, because UnsignedAbs is valid
// for all valid inputs.
typename std::make_unsigned<INT>::type res = value < 0 ? -value : value;
CHR* end = outbuf + kOutputBufSize;
CHR* i = end;
do {
// DCHECK(i != outbuf);
*i = static_cast<CHR>((res % 10) + '0');
res /= 10;
} while (res != 0);
if (value < 0) {
// DCHECK(i != outbuf);
*i = static_cast<CHR>('-');
return std::string(i, end);
namespace glbench {
GLuint SetupTexture(GLsizei size_log2);
GLuint SetupVBO(GLenum target, GLsizeiptr size, const GLvoid* data);
void CreateLattice(GLfloat** vertices,
GLsizeiptr* size,
GLfloat size_x,
GLfloat size_y,
int width,
int height);
int CreateMesh(GLushort** indices,
GLsizeiptr* size,
int width,
int height,
int culled_ratio);
GLuint InitShaderProgram(const char* vertex_src, const char* fragment_src);
GLuint InitShaderProgramWithHeader(const char* header,
const char* vertex_src,
const char* fragment_src);
GLuint InitShaderProgramWithHeaders(const char** headers,
int count,
const char* vertex_src,
const char* fragment_src);
void ClearBuffers();
} // namespace glbench
class Callback {
void Reset() { bind_state_ = NULL; }
bool is_null() const { return !bind_state_; }
void Run() { bind_state_(); }
void Set(std::function<void()> func) { bind_state_ = func; }
std::function<void()> bind_state_;
// Macro for hinting that an expression is likely to be false.
#if !defined(UNLIKELY)
#if defined(COMPILER_GCC) || defined(__clang__)
#define UNLIKELY(x) __builtin_expect(!!(x), 0)
#define UNLIKELY(x) (x)
#endif // defined(COMPILER_GCC)
#endif // !defined(UNLIKELY)
#define CHECK(condition) UNLIKELY(!(condition)) ? IMMEDIATE_CRASH() : (0)
// trim from start (in place)
static inline void ltrim(std::string& s) {
s.erase(s.begin(), std::find_if(s.begin(), s.end(),
[](int ch) { return !std::isspace(ch); }));
// trim from end (in place)
static inline void rtrim(std::string& s) {
s.erase(std::find_if(s.rbegin(), s.rend(),
[](int ch) { return !std::isspace(ch); })
// trim from both ends (in place)
static inline void trim(std::string& s) {
// Put this in the declarations for a class to be uncopyable.
#define DISALLOW_COPY(TypeName) TypeName(const TypeName&) = delete
// Put this in the declarations for a class to be unassignable.
#define DISALLOW_ASSIGN(TypeName) TypeName& operator=(const TypeName&) = delete
// Put this in the declarations for a class to be uncopyable and unassignable.
#endif // BENCH_GL_UTILS_H_