1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ProfilingUtils.hpp"
#include <armnn/Version.hpp>
#include <boost/assert.hpp>
#include <fstream>
#include <limits>
#include <mutex>
namespace armnn
{
namespace profiling
{
uint16_t GetNextUid()
{
// Static mutex for reading and modifying the global UID a single thread at the time
static std::mutex mutex;
std::unique_lock<std::mutex> lock(mutex);
// The UID used for profiling objects and events. The first valid UID is 1, as 0 is a reserved value
// (it is used to indicate that a record is not associated with any device)
static uint16_t uid{ 0 };
// Check that it is possible to generate the next UID without causing an overflow
if (uid == std::numeric_limits<uint16_t>::max())
{
throw RuntimeException("Generating the next UID for profiling would result in an overflow");
}
// Thread safe increment, the value that is incremented is the value checked for overflow,
// as this whole function is mutexed
return ++uid;
}
void WriteUint64(unsigned char* buffer, unsigned int offset, uint64_t value)
{
BOOST_ASSERT(buffer);
buffer[offset] = static_cast<unsigned char>(value & 0xFF);
buffer[offset + 1] = static_cast<unsigned char>((value >> 8) & 0xFF);
buffer[offset + 2] = static_cast<unsigned char>((value >> 16) & 0xFF);
buffer[offset + 3] = static_cast<unsigned char>((value >> 24) & 0xFF);
buffer[offset + 4] = static_cast<unsigned char>((value >> 32) & 0xFF);
buffer[offset + 5] = static_cast<unsigned char>((value >> 40) & 0xFF);
buffer[offset + 6] = static_cast<unsigned char>((value >> 48) & 0xFF);
buffer[offset + 7] = static_cast<unsigned char>((value >> 56) & 0xFF);
}
void WriteUint32(unsigned char* buffer, unsigned int offset, uint32_t value)
{
BOOST_ASSERT(buffer);
buffer[offset] = static_cast<unsigned char>(value & 0xFF);
buffer[offset + 1] = static_cast<unsigned char>((value >> 8) & 0xFF);
buffer[offset + 2] = static_cast<unsigned char>((value >> 16) & 0xFF);
buffer[offset + 3] = static_cast<unsigned char>((value >> 24) & 0xFF);
}
void WriteUint16(unsigned char* buffer, unsigned int offset, uint16_t value)
{
BOOST_ASSERT(buffer);
buffer[offset] = static_cast<unsigned char>(value & 0xFF);
buffer[offset + 1] = static_cast<unsigned char>((value >> 8) & 0xFF);
}
uint64_t ReadUint64(const unsigned char* buffer, unsigned int offset)
{
BOOST_ASSERT(buffer);
uint64_t value = 0;
value = static_cast<uint64_t>(buffer[offset]);
value |= static_cast<uint64_t>(buffer[offset + 1]) << 8;
value |= static_cast<uint64_t>(buffer[offset + 2]) << 16;
value |= static_cast<uint64_t>(buffer[offset + 3]) << 24;
value |= static_cast<uint64_t>(buffer[offset + 4]) << 32;
value |= static_cast<uint64_t>(buffer[offset + 5]) << 40;
value |= static_cast<uint64_t>(buffer[offset + 6]) << 48;
value |= static_cast<uint64_t>(buffer[offset + 7]) << 56;
return value;
}
uint32_t ReadUint32(const unsigned char* buffer, unsigned int offset)
{
BOOST_ASSERT(buffer);
uint32_t value = 0;
value = static_cast<uint32_t>(buffer[offset]);
value |= static_cast<uint32_t>(buffer[offset + 1]) << 8;
value |= static_cast<uint32_t>(buffer[offset + 2]) << 16;
value |= static_cast<uint32_t>(buffer[offset + 3]) << 24;
return value;
}
uint16_t ReadUint16(const unsigned char* buffer, unsigned int offset)
{
BOOST_ASSERT(buffer);
uint32_t value = 0;
value = static_cast<uint32_t>(buffer[offset]);
value |= static_cast<uint32_t>(buffer[offset + 1]) << 8;
return static_cast<uint16_t>(value);
}
std::string GetSoftwareInfo()
{
return std::string("ArmNN");
}
std::string GetHardwareVersion()
{
return std::string();
}
std::string GetSoftwareVersion()
{
std::string armnnVersion(ARMNN_VERSION);
std::string result = "Armnn " + armnnVersion.substr(2,2) + "." + armnnVersion.substr(4,2);
return result;
}
std::string GetProcessName()
{
std::ifstream comm("/proc/self/comm");
std::string name;
getline(comm, name);
return name;
}
} // namespace profiling
} // namespace armnn
|
