Clang format

Change-Id: I2ebac7df9c4716be7fee10ce4cba350e40860ca2

3 files changed, 97 insertions, 132 deletions

diff --git a/driver_library/include/ethosu.hpp b/driver_library/include/ethosu.hpp
index c3a310c..4e45485 100644
--- a/driver_library/include/ethosu.hpp
+++ b/driver_library/include/ethosu.hpp
@@ -25,12 +25,9 @@
 #include <string>
 #include <vector>
 
-namespace EthosU
-{
+namespace EthosU {
 
-class Exception :
-    public std::exception
-{
+class Exception : public std::exception {
 public:
     Exception(const char *msg);
     virtual ~Exception() throw();
@@ -40,8 +37,7 @@ private:
     std::string msg;
 };
 
-class Device
-{
+class Device {
 public:
     Device(const char *device = "/dev/ethosu0");
     virtual ~Device();
@@ -52,8 +48,7 @@ private:
     int fd;
 };
 
-class Buffer
-{
+class Buffer {
 public:
     Buffer(Device &device, const size_t capacity);
     virtual ~Buffer();
@@ -73,8 +68,7 @@ private:
     const size_t dataCapacity;
 };
 
-class Network
-{
+class Network {
 public:
     Network(Device &device, std::shared_ptr<Buffer> &buffer);
     virtual ~Network();
@@ -93,13 +87,15 @@ private:
     std::vector<size_t> ofmDims;
 };
 
-class Inference
-{
+class Inference {
 public:
     template <typename T>
-    Inference(std::shared_ptr<Network> &network, const T &ifmBegin, const T &ifmEnd, const T &ofmBegin, const T &ofmEnd) :
-        network(network)
-    {
+    Inference(std::shared_ptr<Network> &network,
+              const T &ifmBegin,
+              const T &ifmEnd,
+              const T &ofmBegin,
+              const T &ofmEnd) :
+        network(network) {
         std::copy(ifmBegin, ifmEnd, std::back_inserter(ifmBuffers));
         std::copy(ofmBegin, ofmEnd, std::back_inserter(ofmBuffers));
         create();
@@ -122,4 +118,4 @@ private:
     std::vector<std::shared_ptr<Buffer>> ofmBuffers;
 };
 
-}
+} // namespace EthosU
diff --git a/driver_library/src/autogen/.clang-format b/driver_library/src/autogen/.clang-format
new file mode 100644
index 0000000..e45a760
--- /dev/null
+++ b/driver_library/src/autogen/.clang-format
@@ -0,0 +1,23 @@
+#
+# Copyright (c) 2019-2020 Arm Limited. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the License); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an AS IS BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+---
+Language: Cpp
+SortIncludes: false
+DisableFormat: true
+---
diff --git a/driver_library/src/ethosu.cpp b/driver_library/src/ethosu.cpp
index 39e39f0..9de26af 100644
--- a/driver_library/src/ethosu.cpp
+++ b/driver_library/src/ethosu.cpp
@@ -25,21 +25,18 @@
 #include <exception>
 #include <iostream>
 
-#include <sys/ioctl.h>
-#include <sys/mman.h>
 #include <fcntl.h>
 #include <poll.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
 #include <unistd.h>
 
 using namespace std;
 
-namespace
-{
-int eioctl(int fd, unsigned long cmd, void *data = nullptr)
-{
+namespace {
+int eioctl(int fd, unsigned long cmd, void *data = nullptr) {
     int ret = ::ioctl(fd, cmd, data);
-    if (ret < 0)
-    {
+    if (ret < 0) {
         throw EthosU::Exception("IOCTL failed");
     }
 
@@ -50,29 +47,24 @@ int eioctl(int fd, unsigned long cmd, void *data = nullptr)
  * TFL micro helpers
  ****************************************************************************/
 
-size_t getShapeSize(const flatbuffers::Vector<int32_t> *shape)
-{
+size_t getShapeSize(const flatbuffers::Vector<int32_t> *shape) {
     size_t size = 1;
-    
-    for (auto it = shape->begin(); it != shape->end(); ++it)
-    {
+
+    for (auto it = shape->begin(); it != shape->end(); ++it) {
         size *= *it;
     }
 
     return size;
 }
 
-vector<size_t> getSubGraphDims(const tflite::SubGraph *subgraph, const flatbuffers::Vector<int32_t> *tensorMap)
-{
+vector<size_t> getSubGraphDims(const tflite::SubGraph *subgraph, const flatbuffers::Vector<int32_t> *tensorMap) {
     vector<size_t> dims;
 
-    for (auto index = tensorMap->begin(); index != tensorMap->end(); ++index)
-    {
+    for (auto index = tensorMap->begin(); index != tensorMap->end(); ++index) {
         auto tensor = subgraph->tensors()->Get(*index);
         size_t size = getShapeSize(tensor->shape());
 
-        if (size > 0)
-        {
+        if (size > 0) {
             dims.push_back(size);
         }
     }
@@ -80,24 +72,19 @@ vector<size_t> getSubGraphDims(const tflite::SubGraph *subgraph, const flatbuffe
     return dims;
 }
 
-}
+} // namespace
 
-namespace EthosU
-{
+namespace EthosU {
 
 /****************************************************************************
  * Exception
  ****************************************************************************/
 
-Exception::Exception(const char *msg) :
-    msg(msg)
-{}
+Exception::Exception(const char *msg) : msg(msg) {}
 
-Exception::~Exception() throw()
-{}
+Exception::~Exception() throw() {}
 
-const char *Exception::what() const throw()
-{
+const char *Exception::what() const throw() {
     return msg.c_str();
 }
 
@@ -105,22 +92,18 @@ const char *Exception::what() const throw()
  * Device
  ****************************************************************************/
 
-Device::Device(const char *device)
-{
+Device::Device(const char *device) {
     fd = open(device, O_RDWR | O_NONBLOCK);
-    if (fd < 0)
-    {
+    if (fd < 0) {
         throw Exception("Failed to open device");
     }
 }
 
-Device::~Device()
-{
+Device::~Device() {
     close(fd);
 }
 
-int Device::ioctl(unsigned long cmd, void *data)
-{
+int Device::ioctl(unsigned long cmd, void *data) {
     return eioctl(fd, cmd, data);
 }
 
@@ -128,67 +111,54 @@ int Device::ioctl(unsigned long cmd, void *data)
  * Buffer
  ****************************************************************************/
 
-Buffer::Buffer(Device &device, const size_t capacity) :
-    fd(-1),
-    dataPtr(nullptr),
-    dataCapacity(capacity)
-{
-    ethosu_uapi_buffer_create uapi = { static_cast<uint32_t>(dataCapacity) };
-    fd = device.ioctl(ETHOSU_IOCTL_BUFFER_CREATE, static_cast<void *>(&uapi));
+Buffer::Buffer(Device &device, const size_t capacity) : fd(-1), dataPtr(nullptr), dataCapacity(capacity) {
+    ethosu_uapi_buffer_create uapi = {static_cast<uint32_t>(dataCapacity)};
+    fd                             = device.ioctl(ETHOSU_IOCTL_BUFFER_CREATE, static_cast<void *>(&uapi));
 
     void *d = ::mmap(nullptr, dataCapacity, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
-    if (d == MAP_FAILED)
-    {
+    if (d == MAP_FAILED) {
         throw Exception("MMap failed");
     }
 
     dataPtr = reinterpret_cast<char *>(d);
 }
 
-Buffer::~Buffer()
-{
+Buffer::~Buffer() {
     close(fd);
 }
 
-size_t Buffer::capacity() const
-{
+size_t Buffer::capacity() const {
     return dataCapacity;
 }
 
-void Buffer::clear()
-{
+void Buffer::clear() {
     resize(0, 0);
 }
 
-char *Buffer::data()
-{
+char *Buffer::data() {
     return dataPtr + offset();
 }
 
-void Buffer::resize(size_t size, size_t offset)
-{
+void Buffer::resize(size_t size, size_t offset) {
     ethosu_uapi_buffer uapi;
     uapi.offset = offset;
-    uapi.size = size;
+    uapi.size   = size;
     eioctl(fd, ETHOSU_IOCTL_BUFFER_SET, static_cast<void *>(&uapi));
 }
 
-size_t Buffer::offset() const
-{
+size_t Buffer::offset() const {
     ethosu_uapi_buffer uapi;
     eioctl(fd, ETHOSU_IOCTL_BUFFER_GET, static_cast<void *>(&uapi));
     return uapi.offset;
 }
 
-size_t Buffer::size() const
-{
+size_t Buffer::size() const {
     ethosu_uapi_buffer uapi;
     eioctl(fd, ETHOSU_IOCTL_BUFFER_GET, static_cast<void *>(&uapi));
     return uapi.size;
 }
 
-int Buffer::getFd() const
-{
+int Buffer::getFd() const {
     return fd;
 }
 
@@ -196,70 +166,58 @@ int Buffer::getFd() const
  * Network
  ****************************************************************************/
 
-Network::Network(Device &device, shared_ptr<Buffer> &buffer) :
-    fd(-1),
-    buffer(buffer)
-{
+Network::Network(Device &device, shared_ptr<Buffer> &buffer) : fd(-1), buffer(buffer) {
     // Create buffer handle
     ethosu_uapi_network_create uapi;
     uapi.fd = buffer->getFd();
-    fd = device.ioctl(ETHOSU_IOCTL_NETWORK_CREATE, static_cast<void *>(&uapi));
+    fd      = device.ioctl(ETHOSU_IOCTL_NETWORK_CREATE, static_cast<void *>(&uapi));
 
     // Create model handle
     const tflite::Model *model = tflite::GetModel(reinterpret_cast<void *>(buffer->data()));
 
     // Get input dimensions for first subgraph
     auto *subgraph = *model->subgraphs()->begin();
-    ifmDims = getSubGraphDims(subgraph, subgraph->inputs());
+    ifmDims        = getSubGraphDims(subgraph, subgraph->inputs());
 
     // Get output dimensions for last subgraph
     subgraph = *model->subgraphs()->rbegin();
-    ofmDims = getSubGraphDims(subgraph, subgraph->outputs());
+    ofmDims  = getSubGraphDims(subgraph, subgraph->outputs());
 }
 
-Network::~Network()
-{
+Network::~Network() {
     close(fd);
 }
 
-int Network::ioctl(unsigned long cmd, void *data)
-{
+int Network::ioctl(unsigned long cmd, void *data) {
     return eioctl(fd, cmd, data);
 }
 
-shared_ptr<Buffer> Network::getBuffer()
-{
+shared_ptr<Buffer> Network::getBuffer() {
     return buffer;
 }
 
-const std::vector<size_t> &Network::getIfmDims() const
-{
+const std::vector<size_t> &Network::getIfmDims() const {
     return ifmDims;
 }
 
-size_t Network::getIfmSize() const
-{
+size_t Network::getIfmSize() const {
     size_t size = 0;
 
-    for (auto s: ifmDims)
-    {
+    for (auto s : ifmDims) {
         size += s;
     }
 
     return size;
 }
 
-const std::vector<size_t> &Network::getOfmDims() const
-{
+const std::vector<size_t> &Network::getOfmDims() const {
     return ofmDims;
 }
 
-size_t Network::getOfmSize() const
-{
+size_t Network::getOfmSize() const {
     size_t size = 0;
 
-    for (auto s: ofmDims)
-    {
+    for (auto s : ofmDims) {
         size += s;
     }
 
@@ -270,46 +228,39 @@ size_t Network::getOfmSize() const
  * Inference
  ****************************************************************************/
 
-Inference::~Inference()
-{
+Inference::~Inference() {
     close(fd);
 }
 
-void Inference::create()
-{
+void Inference::create() {
     ethosu_uapi_inference_create uapi;
 
-    if (ifmBuffers.size() > ETHOSU_FD_MAX)
-    {
+    if (ifmBuffers.size() > ETHOSU_FD_MAX) {
         throw Exception("IFM buffer overflow");
     }
 
-    if (ofmBuffers.size() > ETHOSU_FD_MAX)
-    {
+    if (ofmBuffers.size() > ETHOSU_FD_MAX) {
         throw Exception("OFM buffer overflow");
     }
 
     uapi.ifm_count = 0;
-    for (auto it: ifmBuffers)
-    {
+    for (auto it : ifmBuffers) {
         uapi.ifm_fd[uapi.ifm_count++] = it->getFd();
     }
 
     uapi.ofm_count = 0;
-    for (auto it: ofmBuffers)
-    {
+    for (auto it : ofmBuffers) {
         uapi.ofm_fd[uapi.ofm_count++] = it->getFd();
     }
 
     fd = network->ioctl(ETHOSU_IOCTL_INFERENCE_CREATE, static_cast<void *>(&uapi));
 }
 
-void Inference::wait(int timeoutSec)
-{
+void Inference::wait(int timeoutSec) {
     pollfd pfd;
 
-    pfd.fd = fd;
-    pfd.events = POLLIN | POLLERR;
+    pfd.fd      = fd;
+    pfd.events  = POLLIN | POLLERR;
     pfd.revents = 0;
 
     int ret = ::poll(&pfd, 1, timeoutSec * 1000);
@@ -317,31 +268,26 @@ void Inference::wait(int timeoutSec)
     cout << "Poll. ret=" << ret << ", revents=" << pfd.revents << endl;
 }
 
-bool Inference::failed()
-{
+bool Inference::failed() {
     ethosu_uapi_status status = static_cast<ethosu_uapi_status>(eioctl(fd, ETHOSU_IOCTL_INFERENCE_STATUS));
 
     return status != ETHOSU_UAPI_STATUS_OK;
 }
 
-int Inference::getFd()
-{
+int Inference::getFd() {
     return fd;
 }
 
-shared_ptr<Network> Inference::getNetwork()
-{
+shared_ptr<Network> Inference::getNetwork() {
     return network;
 }
 
-vector<shared_ptr<Buffer>> &Inference::getIfmBuffers()
-{
+vector<shared_ptr<Buffer>> &Inference::getIfmBuffers() {
     return ifmBuffers;
 }
 
-vector<shared_ptr<Buffer>> &Inference::getOfmBuffers()
-{
+vector<shared_ptr<Buffer>> &Inference::getOfmBuffers() {
     return ofmBuffers;
 }
 
-}
+} // namespace EthosU