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
|
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "common/include/NetworkSockets.hpp"
#include "../../../../src/profiling/Packet.hpp"
#include "common/include/SocketConnectionException.hpp"
#include <string>
#include <atomic>
namespace armnnProfiling
{
enum class TargetEndianness
{
BeWire,
LeWire
};
enum class PacketDirection
{
Sending,
ReceivedHeader,
ReceivedData
};
class ConnectionHandler;
class BasePipeServer
{
public:
BasePipeServer(armnnUtils::Sockets::Socket clientConnection, bool echoPackets)
: m_ClientConnection(clientConnection)
, m_EchoPackets(echoPackets)
{}
~BasePipeServer()
{
// We have set SOCK_CLOEXEC on this socket but we'll close it to be good citizens.
armnnUtils::Sockets::Close(m_ClientConnection);
}
BasePipeServer(const BasePipeServer&) = delete;
BasePipeServer& operator=(const BasePipeServer&) = delete;
BasePipeServer(BasePipeServer&&) = delete;
BasePipeServer& operator=(BasePipeServer&&) = delete;
/// Close the client connection
/// @return 0 if successful
int Close()
{
return armnnUtils::Sockets::Close(m_ClientConnection);
}
/// Send a packet to the client
/// @return true if a valid packet has been sent.
bool SendPacket(uint32_t packetFamily, uint32_t packetId, const uint8_t* data, uint32_t dataLength);
/// Set the client socket to nonblocking
/// @return true if successful.
bool SetNonBlocking()
{
return armnnUtils::Sockets::SetNonBlocking(m_ClientConnection);
}
/// Block on the client connection until a complete packet has been received.
/// @return true if a valid packet has been received.
armnn::profiling::Packet WaitForPacket(uint32_t timeoutMs);
/// Once the connection is open wait to receive the stream meta data packet from the client. Reading this
/// packet differs from others as we need to determine endianness.
/// @return true only if a valid stream meta data packet has been received.
bool WaitForStreamMetaData();
uint32_t GetStreamMetadataVersion()
{
return m_StreamMetaDataVersion;
}
uint32_t GetStreamMetadataMaxDataLen()
{
return m_StreamMetaDataMaxDataLen;
}
uint32_t GetStreamMetadataPid()
{
return m_StreamMetaDataPid;
}
private:
void EchoPacket(PacketDirection direction, uint8_t* packet, size_t lengthInBytes);
bool ReadFromSocket(uint8_t* packetData, uint32_t expectedLength);
bool ReadHeader(uint32_t headerAsWords[2]);
armnn::profiling::Packet ReceivePacket();
uint32_t ToUint32(uint8_t* data, TargetEndianness endianness);
void InsertU32(uint32_t value, uint8_t* data, TargetEndianness endianness);
armnnUtils::Sockets::Socket m_ClientConnection;
bool m_EchoPackets;
TargetEndianness m_Endianness;
uint32_t m_StreamMetaDataVersion;
uint32_t m_StreamMetaDataMaxDataLen;
uint32_t m_StreamMetaDataPid;
};
} // namespace armnnProfiling
|
