1 /* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
2
3 Licensed under the Apache License, Version 2.0 (the "License");
4 you may not use this file except in compliance with the License.
5 You may obtain a copy of the License at
6
7 http://www.apache.org/licenses/LICENSE-2.0
8
9 Unless required by applicable law or agreed to in writing, software
10 distributed under the License is distributed on an "AS IS" BASIS,
11 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 See the License for the specific language governing permissions and
13 limitations under the License.
14 ==============================================================================*/
15
16 #ifndef TENSORFLOW_CORE_PROFILER_UTILS_MATH_UTILS_H_
17 #define TENSORFLOW_CORE_PROFILER_UTILS_MATH_UTILS_H_
18
19 #include <cstdint>
20
21 namespace tensorflow {
22 namespace profiler {
23
24 // Converts among different SI units.
25 // https://en.wikipedia.org/wiki/International_System_of_Units
26 // NOTE: We use uint64 for picos and nanos, which are used in
27 // storage, and double for other units that are used in the UI.
PicoToNano(uint64_t p)28 inline double PicoToNano(uint64_t p) { return p / 1E3; }
PicoToMicro(uint64_t p)29 inline double PicoToMicro(uint64_t p) { return p / 1E6; }
PicoToMilli(uint64_t p)30 inline double PicoToMilli(uint64_t p) { return p / 1E9; }
PicoToUni(uint64_t p)31 inline double PicoToUni(uint64_t p) { return p / 1E12; }
NanoToPico(uint64_t n)32 inline uint64_t NanoToPico(uint64_t n) { return n * 1000; }
NanoToMicro(uint64_t n)33 inline double NanoToMicro(uint64_t n) { return n / 1E3; }
NanoToMilli(uint64_t n)34 inline double NanoToMilli(uint64_t n) { return n / 1E6; }
MicroToNano(double u)35 inline double MicroToNano(double u) { return u * 1E3; }
MicroToMilli(double u)36 inline double MicroToMilli(double u) { return u / 1E3; }
MilliToPico(double m)37 inline uint64_t MilliToPico(double m) { return m * 1E9; }
MilliToNano(double m)38 inline uint64_t MilliToNano(double m) { return m * 1E6; }
MilliToUni(double m)39 inline double MilliToUni(double m) { return m / 1E3; }
UniToPico(double uni)40 inline uint64_t UniToPico(double uni) { return uni * 1E12; }
UniToNano(double uni)41 inline uint64_t UniToNano(double uni) { return uni * 1E9; }
UniToMicro(double uni)42 inline double UniToMicro(double uni) { return uni * 1E6; }
UniToGiga(double uni)43 inline double UniToGiga(double uni) { return uni / 1E9; }
GigaToUni(double giga)44 inline double GigaToUni(double giga) { return giga * 1E9; }
GigaToTera(double giga)45 inline double GigaToTera(double giga) { return giga / 1E3; }
TeraToGiga(double tera)46 inline double TeraToGiga(double tera) { return tera * 1E3; }
47
48 // Convert from clock cycles to seconds.
CyclesToSeconds(double cycles,double frequency_hz)49 inline double CyclesToSeconds(double cycles, double frequency_hz) {
50 // cycles / (cycles/s) = s.
51 return cycles / frequency_hz;
52 }
53
54 // Checks the divisor and returns 0 to avoid divide by zero.
SafeDivide(double dividend,double divisor)55 inline double SafeDivide(double dividend, double divisor) {
56 constexpr double kEpsilon = 1.0E-10;
57 if ((-kEpsilon < divisor) && (divisor < kEpsilon)) return 0.0;
58 return dividend / divisor;
59 }
60
GibiToGiga(double gibi)61 inline double GibiToGiga(double gibi) { return gibi * ((1 << 30) / 1.0e9); }
GigaToGibi(double giga)62 inline double GigaToGibi(double giga) { return giga / ((1 << 30) / 1.0e9); }
63
64 // Calculates GiB/s.
GibibytesPerSecond(double gigabytes,double ns)65 inline double GibibytesPerSecond(double gigabytes, double ns) {
66 return GigaToGibi(SafeDivide(gigabytes, ns));
67 }
68
69 } // namespace profiler
70 } // namespace tensorflow
71
72 #endif // TENSORFLOW_CORE_PROFILER_UTILS_MATH_UTILS_H_
73