Из массива В построить массив С, вычеркнув в массиве В все строки и столбцы, содержащие ноль

#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <functional>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <chrono>
#include <random>
using namespace std::placeholders;
 
std::mutex m;
std::condition_variable cv;
enum { END_PROC = -1, END_FIND = -2 };
int ic = END_PROC;
 
void copyRow(std::vector<std::vector<int>> const& m1, std::vector<std::vector<int>>& m2)
{
    ic = END_PROC;
    std::unique_lock<std::mutex> ul{ m };
    void findRow(std::vector<std::vector<int>> const& mtx);
    std::thread tFindRow{ findRow, m1 };
    while (true)
    {
        cv.wait(ul);
        if (ic != END_FIND)
        {
            m2.emplace_back(m1.at(ic));
            ic = END_PROC;
        }
        else
        {
            break;
        }
    }
    tFindRow.join();
}
 
void findRow(std::vector<std::vector<int>> const& m1)
{
    for (int i = 0; i < m1.size(); ++i)
    {
        if (std::all_of(m1.at(i).begin(), m1.at(i).end(), std::bind(std::not_equal_to<int>(), 0, _1)))
        {
            {
                while (ic != END_PROC)
                {
                    std::this_thread::yield();
                }
                std::lock_guard<std::mutex>{m};
                ic = i;
            }
            cv.notify_one();
        }
    }
 
    {
        while (ic != END_PROC)
        {
            std::this_thread::yield();
        }
        std::lock_guard<std::mutex>{m};
        ic = END_FIND;
    }
    cv.notify_one();
}
 
void delCol(std::vector<std::vector<int>> const& m1, std::vector<std::vector<int>>& m2)
{
    ic = END_PROC;
    std::unique_lock<std::mutex> ul{ m };
    void findCol(std::vector<std::vector<int>> const& m1);
    std::thread tFindCol{ findCol, m1 };
    while (true)
    {
        cv.wait(ul);
        if (ic != END_FIND)
        {
            for (auto& vct : m2)
            {
                vct.erase(vct.begin() + ic);
            }
            ic = END_PROC;
        }
        else
        {
            break;
        }
    }
    tFindCol.join();
}
 
void findCol(std::vector<std::vector<int>> const& m1)
{
    for (int j = m1.at(0).size() - 1; j >= 0; --j)
    {
        for (int i = 0; i < m1.size(); ++i)
        {
            if (0 == m1.at(i).at(j))
            {
                {
                    while (ic != END_PROC)
                    {
                        std::this_thread::yield();
                    }
                    std::lock_guard<std::mutex>{m};
                    ic = j;
                }
                cv.notify_one();
                break;
            }
        }
    }
 
    {
        while (ic != END_PROC)
        {
            std::this_thread::yield();
        }
        std::lock_guard<std::mutex>{m};
        ic = END_FIND;
    }
    cv.notify_one();
}
 
// протестировано в MSVS2017
int main()
{
    std::vector<std::vector<int>> m1/*массив B*/, m2/*массив C*/;
 
    int const row = 500, col = 1000; // число строк и столбцов
    m1.resize(row);
    std::mt19937 eng{ std::random_device{}() };
    std::uniform_int_distribution <> dst{1, 100};
    for (auto& vct : m1)
    {
        for (int j = 0; j < col; ++j)
        {
            vct.emplace_back(dst(eng)); // заполнение массива m1 рандомными числами
        }
    }
    for (int i = row - 1; i >= 0; i -= 10)
    {
        m1[i][col - 1] = 0; // вставляем нули в некоторые строки m1
    }
    for (int j = col - 1; j >= 0; j -= 10)
    {
        m1[row - 1][j] = 0; // вставляем нули в некоторые столбцы m1
    }
 
    // удаляем строки и замеряем время (два потока)
    auto tp11 = std::chrono::high_resolution_clock::now();
    copyRow(m1, m2); 
    auto tp12 = std::chrono::high_resolution_clock::now();
 
    // удаляем столбцы и замеряем время (два потока)
    auto tp13 = std::chrono::high_resolution_clock::now();
    delCol(m1, m2); 
    auto tp14 = std::chrono::high_resolution_clock::now();
 
    // вывод результата двухпоточной обработки
    std::cout << "row dur multi: " << std::chrono::duration<double, std::milli>{tp12 - tp11}.count() << std::endl;// время удаления строк, мс
    std::cout << "col dur multi: " << std::chrono::duration<double, std::milli>{tp14 - tp13}.count() << std::endl;// время удаления столбцов, мс
    std::cout << "rows cnt: " << m2.size() << std::endl; // число оставшихся строк
    std::cout << "cols cnt: " << m2.at(0).size() << std::endl; // число оставшихся столбцов
 
 
    m2.clear();
 
    // удаляем строки и замеряем время (один поток)
    auto tp21 = std::chrono::high_resolution_clock::now();
    for (auto const& vct : m1)
    {
        if (std::all_of(vct.begin(), vct.end(), std::bind(std::not_equal_to<int>(), 0, _1)))
        {
            m2.emplace_back(vct);
        }
    }
    auto tp22 = std::chrono::high_resolution_clock::now();
 
    // удаляем столбцы и замеряем время (один поток)
    auto tp23 = std::chrono::high_resolution_clock::now();
    for (int j = m1.at(0).size() - 1; j >= 0; --j)
    {
        for (int i = 0; i < m1.size(); ++i)
        {
            if (0 == m1.at(i).at(j))
            {
                for (auto& vct : m2)
                {
                    vct.erase(vct.begin() + j);
                }
                break;
            }
        }
    }
    auto tp24 = std::chrono::high_resolution_clock::now();
 
    // вывод результата однопоточной обработки
    std::cout << "\nrow dur single: " << std::chrono::duration<double, std::milli>{tp22 - tp21}.count() << std::endl;
    std::cout << "col dur single: " << std::chrono::duration<double, std::milli>{tp24 - tp23}.count() << std::endl;
    std::cout << "rows cnt: " << m2.size() << std::endl;
    std::cout << "cols cnt: " << m2.at(0).size() << std::endl;
 
    //вывод на экран массива m2
    for (auto const& vct : m2)
    {
        for (auto const val : vct)
        {
            //std::cout << std::setw(4) << std::left << val;
        }
        //std::cout << std::endl;
    }
}