2

I have 2 complex, non-symmetric, matrices $A_{1000\times1000}$, $B_{1000\times1000}$ and I am using Matlab to get it's eigenvalues (functions like eig or eigs). Both matrices are different - one is denser and the other one has more complex values. To compare the complexity of the eigenvalue solving process for both matrices I would like to calculate the number of FLOPs needed for this procedure. Of course, it is possible to calculate the time need for the eigenvalue solver to complete its task, but this is highly unstable since a lot of background processes might be creating some noise.

In Matlab, there is no function that would allow me to get FLOPs for eigs but I might use another software, since I only need these matrices $A, B$ which can be exported. Does anyone have an Idea how I could reach my goal?

nicoguaro
  • 8,500
  • 6
  • 23
  • 49
Kosha Misa
  • 183
  • 6
  • 3
    Is there any specific reason for you wanting the number of FLOPs? In general, eigenvalue problems are solved iteratively and then the number of operations is not fixed. – nicoguaro Jun 20 '19 at 16:23
  • sure, I am comparing two similar methods which are solved via eigenvalue problem. Both methods, depending on their configuration produce different matrices. Sometime these matrices are even hermitian. I need to compare the cost of calculation for both methods - the right way to do it is by counting FLOPs. – Kosha Misa Jun 20 '19 at 16:47
  • 3
    "the right way to do it is by counting FLOPs": I beg to differ, for various reasons, some of which are discussed here – GoHokies Jun 20 '19 at 20:32
  • Thanks @GoHokies, I've read through this very interesting discussion. As Matt Knepley and other point out, FLOPs are important for the efficiency analysis, but admitted, not alone - memory-ops should also be taken into account. In my case counting flops makes sense, because I am performing a relative comparison of matrices on the same hardware. – Kosha Misa Jun 21 '19 at 05:48
  • if you really want to count FLOPs four your two test cases (again, I believe this is not a good idea, even if you're doing a relative comparison on the same hardware, as memory bandwidth / arithmetic intensity does play a role), you'll have to get much closer to the hardware - perhaps with CPU event counters or a hardware emulator. – GoHokies Jun 21 '19 at 06:08
  • but let's suppose you do the counts - the first eig call does (ca.) $X$ FLOPs, the second $Y$. is this really useful info? what have you really demonstrated by counting FLOPs? – GoHokies Jun 21 '19 at 06:09
  • ... see also the last post in this thread – GoHokies Jun 21 '19 at 06:13
  • I agree that memory bandwidth is also important and must be taken into account. But if talking about FLOPs - if the the count of FLOPs for $A$ is much higher then for $B$ - it's clear to me, that the algorithm, that produced the matrix $A$ is more expensive (for now, ignoring the cost for matrix assembling). Again - I am comparing two matrices on the same eig method. I would argue that one can draw a solid conclusion this way. If on the other hand I would use different methods, then FLOPs count would not be enough. – Kosha Misa Jun 21 '19 at 06:30
  • That's not entirely true. Because a particular algorithm for $A$ could be bad for $B$ and the opposite for another algorithm. – nicoguaro Jun 21 '19 at 15:03
  • we could argue about that - also in a chat room. I am still convinced that in my case this is the right thing to do, since the algorithms have the same base. But for now, my question remains the same. I am searching for a way to calculate FLOPs for an eigenvalue solving method. Could you please help me with that? – Kosha Misa Jun 22 '19 at 05:33

1 Answers1

3

The solution would be using PAPI (performance API) library http://icl.cs.utk.edu/papi/. There is a Windows and Linux Version. In order to use it on MATLAB or Octave code, you would have to add the mPAPI written by quepas on github : https://github.com/quepas/mPAPI. This however needs PAPI version >= 5.5.1 and since Windows version of PAPI was not continued after version 3.x, you will have to use Linux.

Now it works really fine and counts FLOPs. PAPI has got a lot of predefined events for this.

Kosha Misa
  • 183
  • 6
  • 1
    while I am not entirely sure if counting FLOPs is the right way (not arguing, not the point), it's quite an interesting find of mPAPI/PAPI. I was certainly not aware of it, and it can be very valuable. Definite upvote. – Anton Menshov Jul 04 '19 at 17:45