Become a leader in the IoT community!

New DevHeads get a 320-point leaderboard boost when joining the DevHeads IoT Integration Community. In addition to learning and advising, active community leaders are rewarded with community recognition and free tech stuff. Start your Legendary Collaboration now!

Step 1 of 5

CREATE YOUR PROFILE *Required

OR
Step 2 of 5

WHAT BRINGS YOU TO DEVHEADS? *Choose 1 or more

Collaboration & Work 🤝
Learn & Grow 📚
Contribute Experience & Expertise 🔧
Step 3 of 5

WHAT'S YOUR INTEREST OR EXPERTISE? *Choose 1 or more

Hardware & Design 💡
Embedded Software 💻
Edge Networking
Step 4 of 5

Personalize your profile

Step 5 of 5

Read & agree to our COMMUNITY RULES

  1. We want this server to be a welcoming space! Treat everyone with respect. Absolutely no harassment, witch hunting, sexism, racism, or hate speech will be tolerated.
  2. If you see something against the rules or something that makes you feel unsafe, let staff know by messaging @admin in the "support-tickets" tab in the Live DevChat menu.
  3. No age-restricted, obscene or NSFW content. This includes text, images, or links featuring nudity, sex, hard violence, or other graphically disturbing content.
  4. No spam. This includes DMing fellow members.
  5. You must be over the age of 18 years old to participate in our community.
  6. Our community uses Answer Overflow to index content on the web. By posting in this channel your messages will be indexed on the worldwide web to help others find answers.
  7. You agree to our Terms of Service (https://www.devheads.io/terms-of-service/) and Privacy Policy (https://www.devheads.io/privacy-policy)
By clicking "Finish", you have read and agreed to the our Terms of Service and Privacy Policy.

How can I optimize matrix multiplication performance and reduce L3 cache misses in my C++ library?

I started a C++ library for efficient matrix operations, with a primary focus on matrix multiplication. The target application is scientific computing, of course performance is critical. I implemented a start matrix class and a matrix multiplication function, used SSE instructions for optimization on Intel Core i7 12700K, 32GB DDR4 3200 RAM on visual studio code with clang format extension .
https://github.com/Marveeamasi/image-processing-matrix-multiplier
even after using SSE instructions, the current matrix multiplication implementation started to show significant performance bottlenecks, especially when dealing with large matrices. Profiling results indicate high L3 cache miss rates as the primary culprit

Matrix Matrix::operator*(const Matrix& other) const {
    if (cols_ != other.rows()) {
        exit(1);
    }

    Matrix result(rows_, other.cols_);

    for (int i = 0; i < rows_; ++i) {
        for (int j = 0; j < other.cols_; ++j) {
            double sum = 0.0;
            for (int k = 0; k < cols_; ++k) {
                sum += (*this)(i, k) * other(k, j);
            }
            result(i, j) = sum;
        }
    }

    return result;
}

tried to optimize memory access patterns and loop structure, but performance gains are still limited. Please need help on strategies to improve cache locality, reduce cache misses, and further enhance the overall efficiency of the matrix multiplication operation.
I’m eager to know about different approaches and best practices for high performance matrix computations.

  1. ming_58391#0

    You may already have come across this, but while I have not looked at it in (many!) years – the bible when I did my MSC in Computational Mathematics was “Numerical Recipes in C”
    https://www.grad.hr/nastava/gs/prg/NumericalRecipesinC.pdf

  2. manuel_70200#0

    Where do you actually use SSE instructions? The code you provided does not contain any, as far as I see.

  3. marveeamasi#0

    No .. it’s not used in the code I pushed. It was an alternative , didn’t push it

  4. manuel_70200#0

    Regarding cache locality, try to access memory consecutively. So, if it is your first index, that is multiplied to get the memory position, then keep this fixed to prevent big steps in memory. In your case this would mean the inner most loop should iterate over `j` not over `k`, as `k` is used as first index for the access to `other`. So try:
    “`cpp
    for (int i = 0; i < rows_; ++i) { for (int j = 0; j < other.cols_; ++j) { result(i, j) = 0.0; } for (int k = 0; k < cols_; ++k) { for (int j = 0; j < other.cols_; ++j) { result(i, j) += (*this)(i, k) * other(k, j); } } } ``` This should boost performance quite a bit.

  5. marveeamasi#0

    Thanks @manuel_70200 I understand the logic behind iterating over j in the innermost loop to improve cache locality. By keeping the first memory access index fixed (i), I would increase the chance of accessing adjacent elements in the same cache line.

    It makes perfect sense in the context of reducing L3 cache misses. I’ll definitely give this approach a try and compare the performance with the original loop structure. It would be interesting to see how much this optimization impacts the overall execution time, especially for larger matrices ✅ ,
    If you check out my new commits I explored using `blocking` also

  6. marveeamasi#0

    Thanks @ming_58391 👍

  7. manuel_70200#0

    you may also search the web for efficient matrix multiplication. this is a standard topic and therefore there should be enough articles how to optimize it

  8. marveeamasi#0

    Yh thanks @manuel_70200 , I tried out using blocking, been pretty okay using it since then , I could try out other optimization techniques for some other projects prolly

CONTRIBUTE TO THIS THREAD

Browse other Product Reviews tagged

Leaderboard

RANKED BY XP

All time
  • 1.
    Avatar
    @Nayel115
    1620 XP
  • 2.
    Avatar
    @UcGee
    650 XP
  • 3.
    Avatar
    @melta101
    600 XP
  • 4.
    Avatar
    @lifegochi
    250 XP
  • 5.
    Avatar
    @Youuce
    180 XP
  • 6.
    Avatar
    @hemalchevli
    170 XP