diff --git a/projects/clr/rocclr/runtime/device/cpu/cpucommand.hpp b/projects/clr/rocclr/runtime/device/cpu/cpucommand.hpp
index 61c3805bde..fe582bcc32 100644
--- a/projects/clr/rocclr/runtime/device/cpu/cpucommand.hpp
+++ b/projects/clr/rocclr/runtime/device/cpu/cpucommand.hpp
@@ -12,7 +12,6 @@
 #include "thread/thread.hpp"
 #include "os/os.hpp"
 #include "amdocl/cl_kernel.h"
-#include "device/cpu/ring.hpp"
 
 #if defined(ATI_ARCH_ARM)
 #include <setjmp.h>
diff --git a/projects/clr/rocclr/runtime/device/cpu/ring.hpp b/projects/clr/rocclr/runtime/device/cpu/ring.hpp
deleted file mode 100644
index 7e36eeba6f..0000000000
--- a/projects/clr/rocclr/runtime/device/cpu/ring.hpp
+++ /dev/null
@@ -1,207 +0,0 @@
-//
-// Copyright 2011 Advanced Micro Devices, Inc. All rights reserved.
-//
-
-#ifndef RING_BUFFER_HPP
-#define RING_BUFFER_HPP
-
-#include "top.hpp"
-#include "thread/atomic.hpp"
-#include "os/alloc.hpp"
-// @brief Block-free ring buffer implemenation
-// @brief THE RING BUFFER SUPPORTS MULTIPLE CONSUMERS AND A SINGLE PRODUCER.
-// @tparam T Object-type to be saved within the ring buffer.
-namespace amd{
-    template <typename T>
-    class RingBuffer
-    {
-    public:
-        ///////////////////////////////////////
-        // public initialization and cleanup //
-        ///////////////////////////////////////
-        RingBuffer();
-        ~RingBuffer() { cleanup();}
-
-        bool 
-        initialize(unsigned short ringBufferSize);
-        //////////////////////
-        // public interface //
-        ///////////////////////
-
-        bool getNext(T & obj);
-        bool insert(const T & obj);
-    private:
-        struct ABACounter{
-            unsigned short tranactionId;
-            unsigned short consumerIndex;
-        };
-
-        union Consumer {
-            ABACounter abaCounter;
-            volatile int32_t interlockedVar;
-        };
-
-        bool canInsert();
-
-        template <typename T2> T2 incrementIndex(T2  index) {
-            index++;
-            if (index == ringBufferSize_)
-                index = 0;
-            return index;
-        }
-        ////////////////////////////////////
-        // read only cache line for       //
-        // producer and consumer threads  //
-        ////////////////////////////////////
-        T * ringBuffer_;
-        unsigned short ringBufferSize_;
-
-        char cachePad1_[64];
-        /////////////////////////////////////
-        // read/write cache line for       //
-        // producer thread                 //
-        /////////////////////////////////////
-        //! producer is an index in the ring buffer array
-        volatile int32_t producer_;
-        //! caches the amount of free space in the buffer. reduces cache misses
-        //! by reducing access to 'm_consumer' from producer thread 
-        int32_t freeSpace_;
-
-        char cachePad2_[64];
-        /////////////////////////////////////
-        // read/write cache line for       //
-        // consumer threads                //
-        /////////////////////////////////////
-        volatile Consumer consumer_;
-
-        /////////////////////////////////////
-        // save the thread that inserts    //
-        // for checking multiple producers //
-        /////////////////////////////////////
-        Thread *producerThread_;
-
-        void cleanup();
-        // do not allow copying
-        RingBuffer(const RingBuffer&);
-        RingBuffer& operator=(const RingBuffer&);
-    };
-
-    template <typename T>
-    RingBuffer<T>::RingBuffer() :
-        ringBuffer_(NULL),
-        ringBufferSize_(0),
-        producer_(0),
-        freeSpace_(0),
-        producerThread_(NULL)
-    { 
-        consumer_.interlockedVar = 0;
-    }
-
-    template <typename T>
-    bool 
-    RingBuffer<T>::initialize(unsigned short  ringBufferSize)
-    {
-        bool retVal = false;
-
-        cleanup();
-        ringBuffer_ = new T [ringBufferSize];
-        if (ringBuffer_)
-        {
-            ringBufferSize_ = ringBufferSize;
-            retVal = true;
-        }
-        return retVal;
-    }
-
-    template <typename T>
-    void 
-    RingBuffer<T>::cleanup()
-    {
-        if (ringBuffer_)
-        {
-            delete [] ringBuffer_;
-            ringBuffer_ = NULL;
-        }
-        producer_ = 0;
-        consumer_.interlockedVar = 0;
-        freeSpace_ = 0;
-        ringBufferSize_ = 0;
-    }
-
-    template <typename T>
-    bool 
-    RingBuffer<T>::insert(const T & obj)
-    {
-#ifdef DEBUG
-        // if this is the 1st insert, set producerThread_
-        if (NULL == producerThread_) {
-            producerThread_ = Thread::current();
-        } else {
-            assert(Thread::current() == producerThread_ && "not a single writer");
-        }
-#endif //DEBUG
-        bool retVal = false;
-        if (canInsert())
-        {
-            ringBuffer_[producer_] = obj;
-
-            producer_ = incrementIndex(producer_);
-            retVal = true;
-        }
-        return retVal;
-    }
-
-    template <typename T>
-    bool 
-    RingBuffer<T>::getNext( T & obj)
-    {
-
-        Consumer consumer;
-        consumer.interlockedVar = consumer_.interlockedVar;
-        //cache the producer variable on the stack  
-        int producer = producer_;
-        //while the buffer is not empty
-        while (producer != consumer.abaCounter.consumerIndex)
-        {
-            obj = ringBuffer_[consumer.abaCounter.consumerIndex];
-            Consumer newConsumer;
-            newConsumer.abaCounter.consumerIndex = incrementIndex(consumer.abaCounter.consumerIndex);
-            newConsumer.abaCounter.tranactionId = consumer.abaCounter.tranactionId+1;
-
-            if (consumer.interlockedVar == amd::AtomicOperation::compareAndSwap(consumer.interlockedVar,
-                &(consumer_.interlockedVar),newConsumer.interlockedVar))
-            {
-                return true;
-            }
-
-            consumer.interlockedVar = consumer_.interlockedVar;
-            producer = producer_;
-        }
-        return false;
-    }
-
-    template <typename T>
-    bool 
-    RingBuffer<T>::canInsert()
-    {
-        if (freeSpace_ > 1)
-        {
-            freeSpace_--;
-            return true;
-        }
-        //cache the volatile variable on the stack;
-        int32_t consumer = consumer_.abaCounter.consumerIndex;
-
-        //there will alway be one unused cell in the array
-        //to distinguish between the case it is completely full and completely empty
-        freeSpace_ = consumer - producer_ - 1  ;
-        if ( freeSpace_ <= -1 )
-        {
-            freeSpace_ = ringBufferSize_ + freeSpace_;
-        }
-        return (freeSpace_ > 0) ;
-    }
-
-}//NAMESPACE AMD
-
-#endif // RING_BUFFER_HPP