text stringlengths 1 24.5M |
|---|
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <common/include/IgnoreUnused.hpp>
#include <common/include/TargetEndianess.hpp>
#include <cstdint>
#include <memory>
#include <vector>
// forward declare to prevent a circular dependency
namespace arm
{
n... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "CounterIdMap.hpp"
#include "Holder.hpp"
#include "ICounterValues.hpp"
#include "IInitialiseProfilingService.hpp"
#include "IProfilingServiceStatus.hpp"
#include "ISendCounterPacket.hpp"
#in... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ILocalPacketHandler.hpp"
#include <common/include/Packet.hpp>
#include <cstdint>
namespace arm
{
namespace pipe
{
class IProfilingServiceStatus
{
public:
virtual void NotifyProfili... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace arm
{
namespace pipe
{
class IProfilingService;
class IReportStructure
{
public:
virtual ~IReportStructure() {}
virtual void ReportStructure(arm::pipe::IProfilingService& profilingService) = 0;
}... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "CounterValue.hpp"
#include <common/include/ICounterDirectory.hpp>
namespace arm
{
namespace pipe
{
class ISendCounterPacket
{
public:
using IndexValuePairsVector = std::vector<CounterValue>;
vi... |
//
// Copyright © 2019, 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <algorithm>
#include <cstdint>
#include <string>
#include <vector>
namespace arm
{
namespace pipe
{
enum class ProfilingRelationshipType
{
RetentionLink, /// Head retains(par... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ILocalPacketHandler.hpp"
#include <string>
#include <vector>
namespace arm
{
namespace pipe
{
/// The lowest performance data capture interval we support is 10 miliseconds.
constexpr unsi... |
//
// Copyright © 2022 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace arm
{
namespace pipe
{
enum class ProfilingState
{
Uninitialised,
NotConnected,
WaitingForAck,
Active
};
} // namespace pipe
} // namespace arm
|
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <client/include/IProfilingService.hpp>
#include <client/include/ISendTimelinePacket.hpp>
namespace arm
{
namespace pipe
{
class TimelineUtilityMethods
{
public:
// static factory met... |
//
// Copyright © 2022 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "CounterValue.hpp"
namespace arm
{
namespace pipe
{
struct Timestamp
{
uint64_t timestamp;
std::vector<CounterValue> counterValues;
};
} // namespace pipe
} // namespace arm
|
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <client/include/CounterStatus.hpp>
#include <client/include/CounterValue.hpp>
#include <client/include/IProfilingService.hpp>
#include <client/include/ISendCounterPacket.hpp>
#include <client/include/ISendTi... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IBackendProfiling.hpp"
#include <common/include/Optional.hpp>
#include <vector>
namespace arm
{
namespace pipe
{
class IBackendProfilingContext
{
public:
virtual ~IBackendProfilingContext()
{}
... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ActivateTimelineReportingCommandHandler.hpp"
#include <client/include/TimelineUtilityMethods.hpp>
#include <common/include/ProfilingException.hpp>
#include <fmt/format.h>
namespace arm
{
namespace p... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ProfilingStateMachine.hpp"
#include "SendTimelinePacket.hpp"
#include "INotifyBackends.hpp"
#include <client/include/IReportStructure.hpp>
#include <common/include/CommandHandlerFunctor.h... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "BufferManager.hpp"
#include "PacketBuffer.hpp"
namespace arm
{
namespace pipe
{
BufferManager::BufferManager(unsigned int numberOfBuffers, unsigned int maxPacketSize)
: m_MaxBufferSize(maxPacketSize),
m_Numb... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IBufferManager.hpp"
#include "IConsumer.hpp"
#if !defined(ARMNN_DISABLE_THREADS)
#include <mutex>
#endif
#include <vector>
#include <queue>
namespace arm
{
namespace pipe
{
class BufferManager : public... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "CommandHandler.hpp"
#include "ProfilingService.hpp"
#include <common/include/Logging.hpp>
#if defined(ARMNN_DISABLE_THREADS)
#include <common/include/IgnoreUnused.hpp>
#endif
namespace arm
{
namespac... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IProfilingConnection.hpp"
#include <common/include/PacketVersionResolver.hpp>
#include <common/include/CommandHandlerRegistry.hpp>
#include <atomic>
#if !defined(ARMNN_DISABLE_THREADS)
#i... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ConnectionAcknowledgedCommandHandler.hpp"
#include <client/include/TimelineUtilityMethods.hpp>
#include <common/include/ProfilingException.hpp>
#include <fmt/format.h>
namespace arm
{
namespace pipe... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ProfilingStateMachine.hpp"
#include <client/include/IProfilingServiceStatus.hpp>
#include <client/include/ISendCounterPacket.hpp>
#include <client/include/ISendTimelinePacket.hpp>
#includ... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <client/include/CounterIdMap.hpp>
#include <common/include/ProfilingException.hpp>
#include <map>
namespace arm
{
namespace pipe
{
void CounterIdMap::RegisterMapping(uint16_t globalCounterId,
... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "DeactivateTimelineReportingCommandHandler.hpp"
#include <common/include/ProfilingException.hpp>
#include <fmt/format.h>
namespace arm
{
namespace pipe
{
void DeactivateTimelineReportingCommandHandl... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ProfilingStateMachine.hpp"
#include "INotifyBackends.hpp"
#include "ProfilingStateMachine.hpp"
#include <common/include/CommandHandlerFunctor.hpp>
#include <common/include/Packet.hpp>
nam... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "FileOnlyProfilingConnection.hpp"
#include <common/include/Constants.hpp>
#include <common/include/ProfilingException.hpp>
#include <common/include/PacketVersionResolver.hpp>
#include <algorithm>
#inclu... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IProfilingConnection.hpp"
#include "ProfilingUtils.hpp"
#include <client/include/ILocalPacketHandler.hpp>
#include <client/include/ProfilingOptions.hpp>
#include <common/include/Assert.hp... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <client/include/Holder.hpp>
namespace arm
{
namespace pipe
{
CaptureData& CaptureData::operator=(const CaptureData& other)
{
m_CapturePeriod = other.m_CapturePeriod;
m_CounterIds = other.m_CounterIds;
... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IConsumer.hpp"
#include "IPacketBuffer.hpp"
#include <memory>
#define MAX_METADATA_PACKET_LENGTH 4096
namespace arm
{
namespace pipe
{
class IBufferManager
{
public:
virtual ~IBufferManager() {}
... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace arm
{
namespace pipe
{
class IConsumer
{
public:
virtual ~IConsumer() {}
/// Set a "ready to read" flag in the buffer to notify the reading thread to start reading it.
virtual void SetReadyTo... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace arm
{
namespace pipe
{
class INotifyBackends
{
public:
virtual ~INotifyBackends() {}
virtual void NotifyBackendsForTimelineReporting() = 0;
};
} // namespace pipe
} // namespace arm
|
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <memory>
namespace arm
{
namespace pipe
{
class IReadOnlyPacketBuffer // interface used by the read thread
{
public:
virtual ~IReadOnlyPacketBuffer() {}
virtual const unsigned char* GetReadableDa... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace arm
{
namespace pipe
{
class IPeriodicCounterCapture
{
public:
virtual ~IPeriodicCounterCapture() {}
virtual void Start() = 0;
virtual void Stop() = 0;
};
} // namespace pipe
} // namespace a... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <client/include/ILocalPacketHandler.hpp>
#include <common/include/Packet.hpp>
#include <cstdint>
namespace arm
{
namespace pipe
{
class IProfilingConnection
{
public:
virtual ~IProfilingConnection()... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IProfilingConnection.hpp"
#include <client/include/ProfilingOptions.hpp>
#include <memory>
namespace arm
{
namespace pipe
{
class IProfilingConnectionFactory
{
public:
using ExternalProfilingOption... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ProfilingService.hpp"
#include <client/include/IProfilingService.hpp>
namespace arm
{
namespace pipe
{
std::unique_ptr<IProfilingService> IProfilingService::CreateProfilingService(
uint16_t maxGl... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IProfilingConnection.hpp"
namespace arm
{
namespace pipe
{
class ISendThread
{
public:
virtual ~ISendThread() {}
/// Start the thread
virtual void Start(IProfilingConnection& profilingConnec... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IProfilingConnection.hpp"
#include <common/include/IgnoreUnused.hpp>
namespace arm
{
namespace pipe
{
class NullProfilingConnection : public IProfilingConnection
{
virtual bool IsOpen() const overri... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "PacketBuffer.hpp"
#include <common/include/ProfilingException.hpp>
namespace arm
{
namespace pipe
{
PacketBuffer::PacketBuffer(unsigned int maxSize)
: m_MaxSize(maxSize)
, m_Size(0)
{
m_Data = std::make_u... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IPacketBuffer.hpp"
#include <memory>
namespace arm
{
namespace pipe
{
class PacketBuffer : public IPacketBuffer
{
public:
PacketBuffer(unsigned int maxSize);
~PacketBuffer() {}
const unsig... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "PeriodicCounterCapture.hpp"
#include <common/include/Logging.hpp>
#include <iostream>
namespace arm
{
namespace pipe
{
void PeriodicCounterCapture::Start()
{
// Check if the capture thread is already running
... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IPeriodicCounterCapture.hpp"
#include "SendCounterPacket.hpp"
#include <client/include/CounterIdMap.hpp>
#include <client/include/Holder.hpp>
#include <client/include/ICounterValues.hpp>
#include <client/... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "PeriodicCounterSelectionCommandHandler.hpp"
#include "ProfilingUtils.hpp"
#include <client/include/ProfilingOptions.hpp>
#include <common/include/NumericCast.hpp>
#include <fmt/format.h>
#include <ve... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ProfilingStateMachine.hpp"
#include "SendCounterPacket.hpp"
#include "IPeriodicCounterCapture.hpp"
#include <client/include/CounterIdMap.hpp>
#include <client/include/Holder.hpp>
#include ... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "PerJobCounterSelectionCommandHandler.hpp"
#include <common/include/CommonProfilingUtils.hpp>
#include <fmt/format.h>
namespace arm
{
namespace pipe
{
void PerJobCounterSelectionCommandHandler::opera... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ProfilingStateMachine.hpp"
#include <common/include/CommandHandlerFunctor.hpp>
#include <common/include/Packet.hpp>
namespace arm
{
namespace pipe
{
class PerJobCounterSelectionCommandH... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ProfilingConnectionDumpToFileDecorator.hpp"
#include <common/include/NumericCast.hpp>
#include <common/include/ProfilingException.hpp>
#include <fstream>
namespace arm
{
namespace pipe
{
ProfilingCo... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IProfilingConnection.hpp"
#include "ProfilingUtils.hpp"
#include <client/include/ProfilingOptions.hpp>
#include <fstream>
#include <memory>
#include <string>
#include <vector>
namespace ... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ProfilingConnectionFactory.hpp"
#include "FileOnlyProfilingConnection.hpp"
#include "ProfilingConnectionDumpToFileDecorator.hpp"
#include "SocketProfilingConnection.hpp"
namespace arm
{
namespace pipe... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IProfilingConnectionFactory.hpp"
namespace arm
{
namespace pipe
{
class ProfilingConnectionFactory final : public IProfilingConnectionFactory
{
public:
ProfilingConnectionFactory() ... |
//
// Copyright © 2019, 2022-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ProfilingService.hpp"
#include <common/include/Logging.hpp>
#include <common/include/NumericCast.hpp>
#include <common/include/ProfilingGuid.hpp>
#include <common/include/SocketConnectionExce... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ActivateTimelineReportingCommandHandler.hpp"
#include "BufferManager.hpp"
#include "CommandHandler.hpp"
#include "ConnectionAcknowledgedCommandHandler.hpp"
#include "DeactivateTimelineRepor... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ProfilingStateMachine.hpp"
#include <common/include/ProfilingException.hpp>
#include <sstream>
namespace arm
{
namespace pipe
{
namespace
{
void ThrowStateTransitionException(ProfilingState expectedState, Profiling... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <client/include/ProfilingState.hpp>
#include <common/include/IgnoreUnused.hpp>
#include <atomic>
namespace arm
{
namespace pipe
{
class ProfilingStateMachine
{
public:
ProfilingStateMachine() : m_St... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ProfilingUtils.hpp"
#include <common/include/Assert.hpp>
#include <common/include/CommonProfilingUtils.hpp>
#include <common/include/NumericCast.hpp>
#include <common/include/ProfilingException.hpp>
#in... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IPacketBuffer.hpp"
#include <client/include/ISendTimelinePacket.hpp>
#include <common/include/ICounterDirectory.hpp>
#include <common/include/Packet.hpp>
#include <common/include/Profilin... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RegisterBackendCounters.hpp"
namespace arm
{
namespace pipe
{
void RegisterBackendCounters::RegisterCategory(const std::string& categoryName)
{
m_CounterDirectory.RegisterCategory(categoryName);
}
uint16_t Regis... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <client/include/CounterIdMap.hpp>
#include <client/include/IProfilingService.hpp>
#include <client/include/backends/IBackendProfiling.hpp>
#include <common/include/CounterDirectory.hpp>
namespace arm
{
n... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RequestCounterDirectoryCommandHandler.hpp"
#include <fmt/format.h>
namespace arm
{
namespace pipe
{
void RequestCounterDirectoryCommandHandler::operator()(const arm::pipe::Packet& packet)
{
ProfilingState current... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ProfilingStateMachine.hpp"
#include <client/include/ISendCounterPacket.hpp>
#include <client/include/ISendTimelinePacket.hpp>
#include <common/include/CommandHandlerFunctor.hpp>
#include <common/include/P... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "SendCounterPacket.hpp"
#include <common/include/Assert.hpp>
#include <common/include/Conversion.hpp>
#include <common/include/Constants.hpp>
#include <common/include/EncodeVersion.hpp>
#include <common/... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IBufferManager.hpp"
#include "ProfilingUtils.hpp"
#include <client/include/ISendCounterPacket.hpp>
#include <type_traits>
namespace arm
{
namespace pipe
{
class SendCounterPacket : pub... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "SendThread.hpp"
#include "ProfilingUtils.hpp"
#include <common/include/NumericCast.hpp>
#include <common/include/ProfilingException.hpp>
#if defined(ARMNN_DISABLE_THREADS)
#include <common/include/Igno... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IBufferManager.hpp"
#include "IConsumer.hpp"
#include "ISendThread.hpp"
#include "IProfilingConnection.hpp"
#include "ProfilingStateMachine.hpp"
#include "ProfilingUtils.hpp"
#include <client/include/ISend... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "SendTimelinePacket.hpp"
namespace arm
{
namespace pipe
{
void SendTimelinePacket::Commit()
{
if (m_WriteBuffer == nullptr)
{
// Can't commit from a null buffer
return;
}
... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IBufferManager.hpp"
#include "ProfilingUtils.hpp"
#include <client/include/ISendTimelinePacket.hpp>
#include <common/include/Assert.hpp>
#include <memory>
namespace arm
{
namespace pip... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "SocketProfilingConnection.hpp"
#include <common/include/SocketConnectionException.hpp>
#include <cerrno>
#include <cstring>
#include <fcntl.h>
#include <string>
namespace arm
{
namespace pipe
{
Sock... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "IProfilingConnection.hpp"
#include <common/include/NetworkSockets.hpp>
#pragma once
namespace arm
{
namespace pipe
{
class SocketProfilingConnection : public IProfilingConnection
{
public:
Socket... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TimelinePacketWriterFactory.hpp"
#include "SendTimelinePacket.hpp"
namespace arm
{
namespace pipe
{
std::unique_ptr<ISendTimelinePacket> TimelinePacketWriterFactory::GetSendTimelinePacket() const
{
return std::ma... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IBufferManager.hpp"
#include <client/include/ISendTimelinePacket.hpp>
#include <memory>
namespace arm
{
namespace pipe
{
class TimelinePacketWriterFactory
{
public:
TimelinePacketWriterFactory(IBuf... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ProfilingUtils.hpp"
#include <client/include/TimelineUtilityMethods.hpp>
#include <common/include/LabelsAndEventClasses.hpp>
#include <common/include/Threads.hpp>
namespace arm
{
namespace pipe
{
std... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "BackendProfiling.hpp"
#include <client/src/RegisterBackendCounters.hpp>
namespace arm
{
namespace pipe
{
std::unique_ptr<IRegisterBackendCounters>
BackendProfiling::GetCounterRegistrationInterface(uint16_t current... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <client/include/backends/IBackendProfiling.hpp>
#include <client/include/IProfilingService.hpp>
namespace arm
{
namespace pipe
{
class BackendProfiling : public IBackendProfiling
{
public:
BackendProf... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "BackendProfiling.hpp"
#include <client/include/backends/IBackendProfiling.hpp>
namespace arm
{
namespace pipe
{
std::unique_ptr<IBackendProfiling> IBackendProfiling::CreateBackendProfiling(const Prof... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <cassert>
namespace arm
{
namespace pipe
{
#ifndef NDEBUG
# define ARM_PIPE_ASSERT(COND) assert(COND)
# define ARM_PIPE_ASSERT_MSG(COND, MSG) assert((COND) && MSG)
#else
# define AR... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Packet.hpp"
#include <cstdint>
namespace arm
{
namespace pipe
{
class CommandHandlerFunctor
{
public:
CommandHandlerFunctor(uint32_t familyId, uint32_t packetId, uint32_t version)
... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <cstdint>
namespace arm
{
namespace pipe
{
class CommandHandlerKey
{
public:
CommandHandlerKey(uint32_t familyId, uint32_t packetId, uint32_t version)
: m_FamilyId(familyId), m_Pa... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "CommandHandlerFunctor.hpp"
#include "CommandHandlerKey.hpp"
#include <functional>
#include <unordered_map>
namespace arm
{
namespace pipe
{
struct CommandHandlerHash
{
std::size_t o... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ICounterDirectory.hpp"
#include <cstdint>
#include <string>
namespace arm
{
namespace pipe
{
void ReadBytes(const unsigned char* buffer, unsigned int offset, unsigned int valueSize, uint8... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace arm
{
namespace pipe
{
static const unsigned int PIPE_MAGIC = 0x45495434;
} // namespace pipe
} // namespace arm |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#if __GNUC__
# define ARM_PIPE_NO_CONVERSION_WARN_BEGIN \
_Pragma("GCC diagnostic push") \
_Pragma("GCC diagnostic ignored \"-Wconversion\"") \
_Pragma("GCC diagnostic ignored \"-Wsign... |
//
// Copyright © 2022,2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <cstdint>
#include <string>
namespace arm
{
namespace pipe
{
class Counter final
{
public:
// Constructors
Counter(const std::string& backendId,
uint16_t ... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ICounterDirectory.hpp"
#include "ICounterRegistry.hpp"
#include <string>
#include <unordered_set>
#include <unordered_map>
#include <common/include/NumericCast.hpp>
namespace arm
{
name... |
//
// Copyright © 2020 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#if defined (_MSC_VER)
#ifdef ARMNN_COMPILING_DLL
#define ARMNN_DLLEXPORT __declspec(dllexport)
#else
#define ARMNN_DLLEXPORT __declspec(dllimport)
#endif
#else
#define ARMNN_DLLEXPORT
#endif |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <cstdint>
#include <string>
#include <ostream>
#include <sstream>
namespace arm
{
namespace pipe
{
constexpr inline uint32_t EncodeVersion(uint32_t major, uint32_t minor, uint32_t patch)
{... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Counter.hpp"
#include <string>
#include <vector>
#include <memory>
#include <unordered_set>
#include <unordered_map>
namespace arm
{
namespace pipe
{
// Forward declarations
class Category;
class Device... |
//
// Copyright © 2020,2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <common/include/Optional.hpp>
namespace arm
{
namespace pipe
{
class Category;
class Device;
class CounterSet;
class Counter;
class ICounterRegistry
{
public:
virtual ~ICounterR... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace arm
{
namespace pipe
{
// Utility function to selectively silence unused variable compiler warnings
template<typename ... Ts>
inline void IgnoreUnused(Ts&&...){}
} //namespace pipe
} //na... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ProfilingGuid.hpp"
#include <string>
namespace arm
{
namespace pipe
{
class IProfilingGuidGenerator
{
public:
/// Return the next random Guid in the sequence
virtual ProfilingDynamicGuid NextGui... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ProfilingGuidGenerator.hpp"
#include "DllExport.hpp"
namespace arm
{
namespace pipe
{
class LabelsAndEventClasses
{
public:
// Labels (string value + GUID)
ARMNN_DLLEXPORT stati... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <iostream>
#include <memory>
#include <sstream>
#include <vector>
namespace arm
{
namespace pipe
{
#if defined(__clang__) &&((__clang_major__>=3)||(__clang_major__==3 && __clang_minor__ >... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
// This file (along with its corresponding .cpp) defines a very thin platform abstraction layer for the use of
// networking sockets. Thankfully the underlying APIs on Windows and Linux are very similar so not muc... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Assert.hpp"
#include <type_traits>
#include <limits>
namespace arm
{
namespace pipe
{
#if !defined(NDEBUG) || defined(ARM_PIPE_NUMERIC_CAST_TESTABLE)
#define ENABLE_NUMERIC_CAST_CHECKS ... |
//
// Copyright © 2022 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ProfilingException.hpp"
#include <cstring>
#include <type_traits>
/// Optional is a drop in replacement for std::optional until we migrate
/// to c++-17. Only a subset of the optional features are implemen... |
//
// Copyright © 2017, 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ProfilingException.hpp"
#include <cstdint>
#include <memory>
namespace arm
{
namespace pipe
{
class Packet
{
public:
Packet()
: m_Header(0)
, m_PacketFamily(0)... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "EncodeVersion.hpp"
namespace arm
{
namespace pipe
{
class PacketKey final
{
public:
PacketKey(uint32_t familyId, uint32_t packetId) : m_FamilyId(familyId), m_PacketId(packetId) {}
... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace arm
{
namespace pipe
{
int GetCurrentProcessId();
} // namespace arm
} // namespace pipe
|
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <stdexcept>
#include <string>
#include <sstream>
namespace arm
{
namespace pipe
{
struct Location
{
const char* m_Function;
const char* m_File;
unsigned int m_Line;
Locati... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <memory>
#include <stdint.h>
namespace arm
{
namespace pipe
{
static constexpr uint64_t MIN_STATIC_GUID = 1llu << 63;
class ProfilingGuid
{
public:
ProfilingGuid() : m_Guid(0) {}
... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IProfilingGuidGenerator.hpp"
#include "ProfilingGuid.hpp"
#include <functional>
#include <mutex>
namespace arm
{
namespace pipe
{
class ProfilingGuidGenerator : public IProfilingGuidGen... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <sstream>
#include <stdexcept>
#include <string>
#include "NetworkSockets.hpp"
namespace arm
{
namespace pipe
{
/// Socket Connection Exception for profiling
class SocketConnectionExcepti... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "NumericCast.hpp"
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
namespace arm
{
namespace pipe
{
struct SwTraceHeader
{
uint8_t m_StreamVersion;
uin... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.