résultat Benchmark

[AdamNaji]

est ce que ces reusltat semble cohérent? BM_Queue pour les dynamique queue optimisé et BM_QueueBasic pour les queue non optimisé

voici le code du benchmark

const unsigned long fromRange = 8;
const unsigned long toRange = 1 << 10;

static void BM_Queue(benchmark::State& state)
{
    const auto length = state.range(0);
    neko::DynamicQueue<int> queue;
   for (int i = 0; i < length; i++) 
    {

       queue.PushBack(rand()% 32768);

   }

    for (auto _ : state)
    {
        for (size_t i = 0; i < queue.Size(); i++)
        {
            benchmark::DoNotOptimize(queue);
        }
               queue.PopFront();

    }

}
BENCHMARK(BM_Queue)->Range(fromRange, toRange);

static void BM_QueueBasic(benchmark::State& state)
{
    const auto length = state.range(0);
    neko::DynamicQueueBasic<int> queue;
    for (int i = 0; i < length; i++)
    {

        queue.PushBack(rand() % 32768);

    }

    for (auto _ : state)
    {
        for (size_t i = 0; i < queue.Size(); i++)
        {
            benchmark::DoNotOptimize(queue);
        }
        queue.PopFront();

    }
}
BENCHMARK(BM_QueueBasic)->Range(fromRange, toRange);

voici mon script

template<typename T>
    class DynamicQueue
    {
    public:
        DynamicQueue()= default;

        ~DynamicQueue() = default;

        void PushBack(T element)
        {

            if (Size()-1 >= queueVector.size())
            {
                if (!queueVector.empty()) Rebase();
                queueVector.resize(Size()+1);

            }

            queueVector[end_] = element;
            if (end_ + 1 != start_)
            {
                end_++;
            }
            else 
            {
                Rebase();
                end_++;
            }
            if (end_ >= queueVector.size()&& start_ != 0)
            {
                end_ = 0;               
            }

        }
        void Clear()
        {
            queueVector.clear();
            start_ = 0;
            end_ = 0;
        }
        T PopFront()
        {
            T pop = queueVector[start_];
            start_++;
            if (start_> queueVector.size()-1)
            {
                start_ = 0;
            }
            return pop;
        }
        T Front()
        {
            return queueVector[start_];
        }
        T Back()
        {
            if (end_ != 0)
            {
                return queueVector[end_ - 1];
            }

        }
        size_t Size()
        {
            if (start_ == 0 && end_ == 0)
            {
                return 0;
            }
            else 
            {  
                if (end_ > start_)
                {
                    return end_ - start_ +1;
                }

                else 
                {
                    return   start_ - end_+1;
                }
            }
        }

        void Rebase()
        {
            for (size_t i = 0; i < Size()-1; i++)
            {
                queueVector[i] = queueVector[start_ + i];
            }
            end_ = Size()-1;
            start_ = 0;
        }
        T& operator[](size_t idx)
        {
            idx += start_;
            return queueVector[idx];
        }

    private:
        size_t start_ = 0, end_ = 0;
        std::vector<T> queueVector;
    };

    template<typename T>
    class DynamicQueueBasic
    {

    public:
        DynamicQueueBasic() = default;
        ~DynamicQueueBasic() = default;
        void PushBack(T element)
        {
            queueVector.push_back(element);
        };
        void Clear()
        {
            queueVector.clear();
        };
        T PopFront()
        {
            T pop = queueVector[0];

            for (size_t i = 0; i < Size()-1; i++)
            {
                queueVector[i] = queueVector[i+1];
            }

            return pop;
        };
        T Front()
        {
            return queueVector[0];
        };
        T Back()
        {
            return queueVector[Size()-1];
        };
        size_t Size()
        {
            return queueVector.size();
        };
        T& operator[](size_t idx)
        {
            return queueVector[idx];
        };
    private:
        std::vector<T> queueVector;
    };

[EliasFarhan]

Et par rapport au std::queue? C'est cool de comparer les containers que t'as fait toi même, mais il faut comparer avec le standard... Et quand tu push et quand tu pop. T'as aussi bien testé que tes queues fonctionnent correctement? Parce que si je check ton code et qu'il marche pas c'est module raté.

Par contre je sais pas ce que tu fais avec DoNotOptimize, mais c'est n'importe quoi.

for (auto _ : state)
    {
        for (size_t i = 0; i < queue.Size(); i++)
        {
            benchmark::DoNotOptimize(queue); //WTF? Ca sert a rien!
        }
               queue.PopFront(); //Tu checks un seul pop, c'est une queue, on sait que tu Pop au front. 

    }