chromium / chromium / src / 5ddd065e277b5cee7a88f23510eb537280cb26e5 / . / ui / latency / fixed_point.h

// Copyright 2018 The Chromium Authors. All rights reserved. | |

// Use of this source code is governed by a BSD-style license that can be | |

// found in the LICENSE file. | |

#ifndef UI_FRAME_METRICS_FIXED_POINT_H_ | |

#define UI_FRAME_METRICS_FIXED_POINT_H_ | |

#include <cstdint> | |

#include "base/macros.h" | |

namespace ui { | |

namespace frame_metrics { | |

// Use fixed point math so we can manage our precision explicitly and avoid | |

// accumulating error in our windowed accumulators. | |

// The 64-bit accumulators reserve 32-bits for weights, and 32-bits for values. | |

// The 32-bit values reserve 16 bits before and after the radix point. | |

constexpr int kFixedPointShift = 16; | |

constexpr int64_t kFixedPointMultiplier{1LL << kFixedPointShift}; | |

// kFixedPointRootMultiplier is used to shift the bits before taking the square | |

// root and undoing that shift after squaring in the SMR calculation. | |

constexpr int kFixedPointRootShift = 32; | |

constexpr int64_t kFixedPointRootMultiplier{1LL << kFixedPointRootShift}; | |

constexpr int64_t kFixedPointRootMultiplierSqrt{1LL | |

<< (kFixedPointRootShift / 2)}; | |

// We need a huge range to accumulate values for RMS calculations, which | |

// need double the range internally compared to the range we are targeting | |

// after taking the square root of the accumulation. | |

// This efficiently emulates a 96-bit unsigned integer with weighted | |

// accumulation operations. | |

// 32-bits are reserved for weights and 64-bits for squared values. | |

// Overflow or underflow indicates something is seriously wrong with the higher | |

// level metrics logic, so this class will DCHECK if it anticipates overflow | |

// or underflow: | |

// * It doesn't need to support OVERFLOW since the frame metric classes will | |

// always reset the entire accumulator before the accumulated weights | |

// overflow. The accumulated weights correspond to a maximum of the number of | |

// microseconds since the last reset, which for a 32-bit weight is about | |

// 1 hour. We will gather and reset results much more often than every hour. | |

// * It doesn't need to support UNDERFLOW since only the windowed metrics use | |

// Subtract, and those only subtract values it has already added. | |

class Accumulator96b { | |

public: | |

Accumulator96b() = default; | |

Accumulator96b(uint32_t value_to_square, uint32_t weight); | |

void Add(const Accumulator96b& rhs); | |

void Subtract(const Accumulator96b& rhs); | |

double ToDouble() const; | |

public: | |

uint64_t ms64b{0}; | |

uint32_t ls32b{0}; | |

}; | |

// Convenience function overloads for AsDouble, to help with templated code. | |

inline double AsDouble(const Accumulator96b& value) { | |

return value.ToDouble(); | |

} | |

inline double AsDouble(double value) { | |

return value; | |

} | |

} // namespace frame_metrics | |

} // namespace ui | |

#endif // UI_FRAME_METRICS_FIXED_POINT_H_ |