Is this benchmark sufficient to consider my algorithm as an efficient matrix multiplication algorithm? I built a matrix multiplication algorithm and now I need some thoughts about following benchmark.
C++ chrono:: high resolution clock Time(micro second)

(Dim)256--&gt; (Naive algo ) 296807, (My algo) 187479
(Dim)512--&gt; (Naive algo) 2249495, (My algo) 1359046
(Dim)1024--&gt;(Naive algo) 27930970, (My algo) 12309645

FYI, I have no knowledge about strassen matrix multiplication algorithm and how to utilize a github project.Therefore,I stole some benchmark from a github account for sake of some comparisons with strassen matrix mulplication algorithm.Those are as below.
C++ chrono:: high resolution clock Time(micro second)

(Dim)256--&gt;(Naive algo) 260281,(Strassen algo) 216970
(Dim)512--&gt; (Naive algo) 2122299, (Strassen algo) 1580466
(Dim)1024--&gt;(Naive algo) 2algorithm?Strassen algo) 14696774

I don't know specs of github user's computer.I assume it's better than mine after observing both execution times of naive matrix multiplication algorithm.(quoted from https://github.com/rangelak/Strassen-Matrix-Multiplication)
Specs of my computer
Processor core i7 6th gen(2.60 GHz)
Ram 8gb
What do you think about my algorithm after observing above mentioned band what can I expect after comparing my algorithm with strassen matrix multiplication algorithm?
one thing I want to mention is that the strassen's matrix multiplication algorithm isn't often used in the real world and your algo is probably faster if the $n$ stays below a few thousands (explained here: https://stackoverflow.com/questions/13559928/why-is-my-strassens-matrix-multiplication-slow).
Now if you still want to compare your algorithm to the strassens algorithm I would recommend you to copy past a function from somewhere and run it on your computer.
The algorithm would get the same input as your algo and would run on the same hardware.
Here are some implementation of strassens algo:
vectors:
https://github.com/dmonaldo/strassen-matrix-multiplication/blob/master/main.cpp
arrays:
https://www.geeksforgeeks.org/strassens-matrix-multiplication-algorithm-implementation/
When I benchmark an algorithm I always want to plot the results to visualize the complexity. I think more is better; so you should probably use more n not only 256, 512, 1024. Also it would be good to know if your algo is made for a special case like sparse matrices etc. if that's the case you need to pay close attention to the input data, otherwise one algo might have a disadvantage.