From 5f707736413aeac77818c42838296966f8dc6761 Mon Sep 17 00:00:00 2001 From: Anthony Barbier Date: Tue, 3 Jul 2018 16:22:02 +0100 Subject: COMPMID-1369: Revert accidental formatting of RSH's repo Pulled latest fixes from David's repo: commit f43ebe932c84083332b0b1a0348241b69dda63a7 Author: David Mansell Date: Tue Jul 3 18:09:01 2018 +0100 Whitespace tidying, fixed comment in gemv_batched imported from ACL. Change-Id: Ie37a623f44e90d88072236cb853ac55ac82d5f51 Reviewed-on: https://eu-gerrit-1.euhpc.arm.com/138530 Tested-by: Jenkins Reviewed-by: Georgios Pinitas Reviewed-by: Gian Marco Iodice Reviewed-by: David Mansell Reviewed-by: Anthony Barbier --- src/core/NEON/kernels/arm_gemm/buffer_manager.hpp | 198 ++++++++-------------- 1 file changed, 75 insertions(+), 123 deletions(-) (limited to 'src/core/NEON/kernels/arm_gemm/buffer_manager.hpp') diff --git a/src/core/NEON/kernels/arm_gemm/buffer_manager.hpp b/src/core/NEON/kernels/arm_gemm/buffer_manager.hpp index dd74744ebc..03f099d57b 100644 --- a/src/core/NEON/kernels/arm_gemm/buffer_manager.hpp +++ b/src/core/NEON/kernels/arm_gemm/buffer_manager.hpp @@ -38,36 +38,33 @@ #endif -namespace arm_gemm -{ +namespace arm_gemm { + #ifndef NO_MULTI_THREADING -enum class BufferStatus -{ +enum class BufferStatus { IDLE, POPULATING, BUSY }; -class Buffer -{ +class Buffer { private: - const int _maxusers; // Maximum permissible threads. - void *const _storage; // Storage for buffer content. + const int _maxusers; // Maximum permissible threads. + void * const _storage; // Storage for buffer content. - int _numusers; // Actual number of threads (might be lower). + int _numusers; // Actual number of threads (might be lower). - volatile BufferStatus _status = BufferStatus::IDLE; // Status - std::atomic_int _users = {}; // How many users are still using the buffer. - volatile int _index = 0; // Which block of data currently resides in the buffer. + volatile BufferStatus _status = BufferStatus::IDLE; // Status + std::atomic_int _users = { }; // How many users are still using the buffer. + volatile int _index = 0; // Which block of data currently resides in the buffer. - std::mutex _lock = {}; + std::mutex _lock = { }; #ifdef USE_SEMAPHORE - std::condition_variable _cv = {}; + std::condition_variable _cv = { }; #endif template - void populate_buffer(T func) - { + void populate_buffer(T func) { func(_storage); /* Now mark it as ready. */ @@ -78,17 +75,15 @@ private: _cv.notify_all(); } #else - _status = BufferStatus::BUSY; + _status = BufferStatus::BUSY; #endif } public: Buffer(Buffer &) = delete; - Buffer &operator=(Buffer &) = delete; + Buffer &operator= (Buffer &) = delete; - Buffer(void *storage, int maxusers) - : _maxusers(maxusers), _storage(storage), _numusers(maxusers) - { + Buffer(void *storage, int maxusers) : _maxusers(maxusers), _storage(storage), _numusers(maxusers) { _status = BufferStatus::IDLE; } @@ -99,38 +94,32 @@ public: * If it's already being populated by another thread or is ready, return. */ template - void try_populate(const int index, T func) - { - for(;;) - { + void try_populate(const int index, T func) { + for (;;) { #ifdef USE_SEMAPHORE /* If it's busy with a previous index, wait on the semaphore. */ - if((_status == BufferStatus::BUSY) && (_index != index)) - { + if ((_status == BufferStatus::BUSY) && (_index != index)) { std::unique_lock ul(_lock); - if((_status == BufferStatus::BUSY) && (_index != index)) - { + if ((_status == BufferStatus::BUSY) && (_index != index)) { _cv.wait(ul); } } #endif /* Return if another thread is populating it already. */ - if((_index == index) && ((_status == BufferStatus::POPULATING) || (_status == BufferStatus::BUSY))) - { + if ((_index == index) && + ((_status == BufferStatus::POPULATING) || (_status == BufferStatus::BUSY))) { return; } - if(_status == BufferStatus::IDLE) - { + if (_status == BufferStatus::IDLE) { std::lock_guard guard(_lock); /* If the buffer is still idle, we can grab it and populate it. */ - if(_status == BufferStatus::IDLE) - { + if (_status == BufferStatus::IDLE) { _status = BufferStatus::POPULATING; - _index = index; - _users = _numusers; + _index = index; + _users = _numusers; break; } } @@ -141,26 +130,26 @@ public: } template - void *get(const int index, T func) - { + void *get(const int index, T func) { // Loop until we achieve something. - for(;;) - { + for (;;) { // If the index is correct and the buffer status is busy then we can // just return the content. No locking is needed here as the index // cannot change (and status cannot change from BUSY) until all // users have finished. - if((_index == index) && (_status == BufferStatus::BUSY)) - { + if ((_index == index) && (_status == BufferStatus::BUSY)) { return _storage; } + + /* If the buffer still has some previous content, or is being + * populated, we can wait with the semaphore. */ #ifdef USE_SEMAPHORE - if(((_status == BufferStatus::BUSY) && (_index != index)) || (_status == BufferStatus::POPULATING)) - { + if (((_status == BufferStatus::BUSY) && (_index != index)) || + (_status == BufferStatus::POPULATING)) { std::unique_lock ul(_lock); - if(((_status == BufferStatus::BUSY) && (_index != index)) || (_status == BufferStatus::POPULATING)) - { + if (((_status == BufferStatus::BUSY) && (_index != index)) || + (_status == BufferStatus::POPULATING)) { _cv.wait(ul); } } @@ -168,17 +157,15 @@ public: // If it's idle, we need to populate it. The IDLE->POPULATING // transition requires the lock. - if(_status == BufferStatus::IDLE) - { + if (_status == BufferStatus::IDLE) { std::lock_guard guard(_lock); /* If it's still idle, grab it. Otherwise drop through and * we'll do something else next time through the loop. */ - if(_status == BufferStatus::IDLE) - { + if (_status == BufferStatus::IDLE) { _status = BufferStatus::POPULATING; - _index = index; - _users = _numusers; + _index = index; + _users = _numusers; break; } } @@ -194,10 +181,8 @@ public: * simply (atomically) decrement the user count, and if it's hit zero we * flag the buffer as idle. */ - void release(void) - { - if(--_users == 0) - { + void release(void) { + if (--_users == 0) { #ifdef USE_SEMAPHORE std::unique_lock ul(_lock); _status = BufferStatus::IDLE; @@ -211,110 +196,91 @@ public: } /* This is called to change the number of users. */ - void set_numusers(int numusers) - { + void set_numusers(int numusers) { _numusers = std::min(numusers, _maxusers); } }; -class BufferManager -{ + +class BufferManager { private: /* This has to be a vector of Buffer *, because a Buffer cannot be moved * or copied due to atomic members. */ - std::vector _buffers = {}; - const int _maxthreads; - void *const _storage; + std::vector _buffers = { }; + const int _maxthreads; + void * const _storage; public: BufferManager(BufferManager &) = delete; - BufferManager &operator=(BufferManager &) = delete; + BufferManager & operator=(BufferManager &) = delete; // Say how much storage is needed. - static inline size_t get_storage_requirement(const int maxthreads, const size_t buffersize) - { + static inline size_t get_storage_requirement(const int maxthreads, const size_t buffersize) { return buffersize * ((maxthreads == 1) ? 1 : 3); } - BufferManager(const int maxthreads, const size_t buffersize, void *storage) - : _maxthreads(maxthreads), _storage(storage) - { + BufferManager(const int maxthreads, const size_t buffersize, void *storage) : _maxthreads(maxthreads), _storage(storage) { const int numbuffers = (maxthreads == 1) ? 1 : 3; /* We don't need any Buffer objects in single thread mode. */ - if(_maxthreads == 1) - { + if (_maxthreads == 1) { return; } /* Use intptr_t to avoid performing arithmetic on a void * */ intptr_t storage_int = reinterpret_cast(_storage); - for(int i = 0; i < numbuffers; i++) - { + for (int i=0; i(storage_int), _maxthreads)); storage_int += buffersize; } } - ~BufferManager() - { - while(_buffers.size()) - { + ~BufferManager() { + while (_buffers.size()) { delete _buffers.back(); _buffers.pop_back(); } } template - void *get(const int index, T func) - { + void *get(const int index, T func) { /* In single thread mode, we just directly call the populating * function on the (single) buffer, otherwise forward to the * relevant Buffer. */ - if(_maxthreads == 1) - { + if (_maxthreads==1) { func(_storage); return _storage; - } - else - { + } else { return _buffers[index % _buffers.size()]->get(index, func); } } template - void try_populate(const int index, T func) - { + void try_populate(const int index, T func) { /* No need for this in single thread mode. */ - if(_maxthreads == 1) - { + if (_maxthreads==1) { return; } _buffers[index % _buffers.size()]->try_populate(index, func); } - void release(const int index) - { + void release(const int index) { /* No need for this in single thread mode. */ - if(_maxthreads == 1) - { + if (_maxthreads==1) { return; } _buffers[index % _buffers.size()]->release(); } - void set_nthreads(int threads) - { - if(_maxthreads == 1) - { + void set_nthreads(int threads) { + if (_maxthreads==1) { return; } - for(unsigned int i = 0; i < _buffers.size(); i++) - { + for(unsigned int i=0; i<_buffers.size(); i++) { _buffers[i]->set_numusers(threads); } } @@ -329,49 +295,35 @@ public: * All the other methods do nothing. */ -class BufferManager -{ +class BufferManager { private: - void *const _storage; + void * const _storage; public: BufferManager(BufferManager &) = delete; - BufferManager &operator=(BufferManager &) = delete; + BufferManager & operator=(BufferManager &) = delete; - BufferManager(const int maxthreads, const size_t buffersize, void *storage) - : _storage(storage) - { - } + BufferManager(const int maxthreads, const size_t buffersize, void *storage) : _storage(storage) { } - ~BufferManager() - { - } + ~BufferManager() { } // Say how much storage is needed. - static inline size_t get_storage_requirement(const int maxthreads, const size_t buffersize) - { + static inline size_t get_storage_requirement(const int maxthreads, const size_t buffersize) { return buffersize; } template - void try_populate(const int index, T func) - { - } + void try_populate(const int index, T func) { } - void release(const int index) - { - } + void release(const int index) { } template - void *get(const int index, T func) - { + void *get(const int index, T func) { func(_storage); return _storage; } - void set_nthreads(int) - { - } + void set_nthreads(int) { } }; #endif -- cgit v1.2.1