Обработать параллельным способом матрицу с механизмом замков

using namespace std;
HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE);
 
// Создать программу, которая должна реализовать следующие действия:
//1.Створиты матрицу А размером m * n, элементы которой заполняются рандомно, m задает
// количество строк, n задает количество столбцов. Переменные могут задаваться в программном
// коде или вводиться с клавиатуры.
 
const int m = 5, n = 5;
int A[m][n], B[m];
bool visible = true;
omp_lock_t lock; int thread_num;
ofstream out;
 
 
void Mas_A() {
    printf("Массив А: \n");
    for (int i = 0; i < n; i++)
    {
        visible ? printf("Ряд - %d:\t", i + 1) : true;
        for (int j = 0; j < n; j++)
        {
            A[i][j] = GetRandomValue(0, 99);
            if (visible) {printf("%d\t", A[i][j]);}
        }
        visible ? printf("\n") : true;
    }
    cout << endl;
}
 
// 2. Обработать параллельным способом матрицу по своему варианту. каждый поток
// должен обрабатывать несколько строк матрицы. Результаты обработки вывести в текстовый
// файл. При этом перед выводом каждый поток должен выставить блокировки с
// помощью механизма замков.
 
void Par_Min_Value_From_Row(int num) {
    printf("\n\nПоток - %d\n\n", omp_get_thread_num());
#pragma omp parallel num_threads(8)
    {
#pragma omp for 
        for (int i = 0; i < m; i++)
        {
            int min = A[0][0];
            min = A[i][0];
            for (int j = 0; j < n; j++)
            {
                if (A[i][j] < min) {
                    min = A[i][j];
                }
            }
            B[i] = min;
            printf("Строка - %d\t Значение - %d\t поток - %d\n", i + 1, B[i], omp_get_thread_num());
            out << "Строка - " << i + 1 << "\t Значение - " << B[i] << "\t поток - " << omp_get_thread_num() << endl;
        }
    }
}
 
 
// 3. В текстовый файл все потоки по очереди должны вывести сообщение "Начало
// закрытой секции ... "и" Конец закрытой секции ... ". Если при этом между двумя
// сообщениями от одного потока встретятся сообщения от других потоков о
// неудачную попытку войти в закрытой секции, они также должны быть записаны в файл.
 
void writing_to_file() {
 
    omp_init_lock(&lock);
#pragma omp parallel private (thread_num)
    {
        thread_num = omp_get_thread_num();
        while (!omp_test_lock(&lock))
        {
            printf("Секция закрыта, обратился поток %d\n", thread_num);
            out << "Секция закрыта, обратился поток " << thread_num << endl;
            Sleep(2);
        }
 
        printf("Начало закрытой секции, поток %d\n\n", thread_num);
        out << "Начало закрытой секции, поток " << thread_num << endl << endl;
 
        Par_Min_Value_From_Row(thread_num);
        Sleep(5);
        omp_unset_lock(&lock);
        printf("\nКонец закрытой секции, поток %d\n", thread_num);
        out << endl << "Конец закрытой секции, поток " << thread_num << endl;
    }
    omp_destroy_lock(&lock);
}
 
int main()
{
    out.open("lab3.txt", std::ios::app);
    setlocale(0, "rus");
r:
    system("cls");
    Mas_A();
    //Par_Min_Value_From_Row();
    writing_to_file();
 
    char repl;
    cout << "Для повтора введите 'R': "; cin >> repl;
    if (repl == 'R' or repl == 'r') {
        goto r;
    }
    else {
        return 0;
    }
}

void Par_Min_Value_From_Row(int num) 
{
 omp_init_lock(&lock);
    printf("\n\nПоток - %d\n\n", omp_get_thread_num());
#pragma omp parallel num_threads(8)
    {
#pragma omp for 
        for (int i = 0; i < m; i++)
        {
            int min = A[0][0];
            min = A[i][0];
            for (int j = 0; j < n; j++)
            {
                if (A[i][j] < min) {
                    min = A[i][j];
                }
            }
            B[i] = min;
            printf("Строка - %d\t Значение - %d\t поток - %d\n", i + 1, B[i], omp_get_thread_num());
            out << "Строка - " << i + 1 << "\t Значение - " << B[i] << "\t поток - " << omp_get_thread_num() << endl;
        }
omp_test_lock(&lock)
 
.................................................................
omp_unset_lock(&lock);
    }
 
omp_destroy_lock(&lock);
}

void Par_Min_Value_From_Row() {
    omp_init_lock(&lock);
#pragma omp parallel num_threads(4)
    {
#pragma omp for 
        for (int i = 0; i < m; i++)
        {
            int min = A[0][0];
            min = A[i][0];
            for (int j = 0; j < n; j++)
            {
                if (A[i][j] < min) {
                    min = A[i][j];
                }
            }
            B[i] = min;
            printf("Строка - %d\t Значение - %d\t поток - %d\n", i + 1, B[i], omp_get_thread_num());
            out << "Строка - " << i + 1 << "\t Значение - " << B[i] << "\t поток - " << omp_get_thread_num() << endl;
 
        }
        thread_num = omp_get_thread_num();
        while (!omp_test_lock(&lock))
        {
            printf("Секция закрыта, обратился поток %d\n", thread_num);
            out << "Секция закрыта, обратился поток " << thread_num << endl;
            Sleep(2);
        }
        printf("Начало закрытой секции, поток %d\n\n", thread_num);
        out << "Начало закрытой секции, поток " << thread_num << endl << endl;
        Sleep(5);
        printf("\nКонец закрытой секции, поток %d\n", thread_num);
        out << endl << "Конец закрытой секции, поток " << thread_num << endl;
        omp_unset_lock(&lock);
    }
    omp_destroy_lock(&lock);
}

#pragma omp critical (print)
         {
            printf("Строка - %d\t Значение - %d\t поток - %d\n", i + 1, B[i], omp_get_thread_num());
            out << "Строка - " << i + 1 << "\t Значение - " << B[i] << "\t поток - " << omp_get_thread_num() << endl;
         }

void Par_Min_Value_From_Row() {
    omp_init_lock(&lock);
#pragma omp parallel num_threads(4)
    {
#pragma omp for 
        for (int i = 0; i < m; i++)
        {
            int min = A[0][0];
            min = A[i][0];
            for (int j = 0; j < n; j++)
            {
                if (A[i][j] < min) {
                    min = A[i][j];
                }
            }
            B[i] = min;
            SetConsoleTextAttribute(console, (Black | LightMagenta));
#pragma omp critical (print)
            {
                printf("Строка - %d\t Значение - %d\t поток - %d\n", i + 1, B[i], omp_get_thread_num());
                out << "Строка - " << i + 1 << "\t Значение - " << B[i] << "\t поток - " << omp_get_thread_num() << endl;
            }
        }
        while (!omp_test_lock(&lock))
        {
#pragma omp critical (print)
            {
                printf("Секция закрыта, обратился поток %d\n", omp_get_thread_num());
                out << "Секция закрыта, обратился поток " << omp_get_thread_num() << endl;
            }
        }
#pragma omp critical (print)
        {
            printf("Начало закрытой секции, поток %d\n\n", omp_get_thread_num());
            out << "Начало закрытой секции, поток " << omp_get_thread_num() << endl << endl;
        }
#pragma omp critical (print)
        {
            printf("\nКонец закрытой секции, поток %d\n", omp_get_thread_num());
            out << endl << "Конец закрытой секции, поток " << omp_get_thread_num() << endl;
        }
        omp_unset_lock(&lock);
    }
    omp_destroy_lock(&lock);
}

#include <chrono>
#include <exception>
#include <iostream>
#include <random>
#include <thread>
#include <vector>
 
#include <omp.h>
 
// Простой класс для матрицы, который будет хранить данные построчно в
// одномерном массиве.
class Matrix {
public:
  Matrix(size_t rows, size_t cols)
      : m_rows(rows), m_cols(cols), m_data(rows * cols) {}
 
  double *operator[](size_t row) { return &m_data[row * m_cols]; }
  const double *operator[](size_t row) const { return &m_data[row * m_cols]; }
 
  size_t rows() const { return m_rows; }
  size_t cols() const { return m_cols; }
 
private:
  size_t m_rows;
  size_t m_cols;
  std::vector<double> m_data;
};
 
//
// Создать программу, которая должна реализовать следующие действия:
//
 
// 1.Створиты матрицу А размером m * n, элементы которой заполняются рандомно, m
// задает количество строк, n задает количество столбцов. Переменные могут
// задаваться в программном коде или вводиться с клавиатуры.
//
Matrix random_matrix(size_t rows, size_t cols) {
  Matrix A(rows, cols);
  #pragma omp parallel
  {
    // Каждый поток создаёт свою версию объектов для генерации случайных чисел.
    std::mt19937 gen(std::random_device{}());
    std::normal_distribution<> dist;
    #pragma omp for collapse(2)
    for (size_t i = 0; i < rows; ++i) {
      for (size_t j = 0; j < cols; ++j) {
        A[i][j] = dist(gen);
      }
    }
  }
  return A;
}
 
// 2. Обработать параллельным способом матрицу по своему варианту. каждый поток
// должен обрабатывать несколько строк матрицы. Результаты обработки вывести в
// текстовый файл. При этом перед выводом каждый поток должен выставить
// блокировки с помощью механизма замков.
//
// Минимальный элемент для каждой строки с сохранением в файл.
//
// out - поток для записи, может быть или std::cout или std::fostream.
//       Это упростит написание кода.
// A   - матрица для обработки.
//       Нам не надо передавать N и M, т.к. они уже хранятся в классе Matrix.
//
void min_value_from_row(std::ostream &out, const Matrix &A) {
 
  // Локальный замок. Он нужен только для этой задачи. И так будет проще не
  // забыть его уничтожить.
  omp_lock_t lock;
  omp_init_lock(&lock);
 
  #pragma omp parallel
  {
    // Сохраняем номер потока в приватную локальную переменную
    // (она объявлена внутри параллельной секции).
    int thread_num = omp_get_thread_num();
 
    #pragma omp for
    for (size_t i = 0; i < A.rows(); ++i) {
      double min = A[i][0];
      for (size_t j = 1; j < A.cols(); ++j) {
        if (min > A[i][j])
          min = A[i][j];
      }
 
      // Просто блокируем вывод, нас пока попросили только это.
      // Вариант с объединением пунктов 2 и 3 будет позже
      omp_set_lock(&lock);
      out << "thread " << thread_num << ":\t" //
          << "row = " << i << ", \t"          //
          << "min = " << min << "\n";
      omp_unset_lock(&lock);
    }
  }
  omp_destroy_lock(&lock);
}
 
// 3. В текстовый файл все потоки по очереди должны вывести сообщение "Начало
// закрытой секции ... " и " Конец закрытой секции ... ". Если при этом между
// двумя сообщениями от одного потока встретятся сообщения от других потоков о
// неудачную попытку войти в закрытой секции, они также должны быть записаны в
// файл.
//
// Обратим внимание, что в файл потоки должны писать в независимости от того,
// внутри они закрытой секции или нет. Т.к. файл - это общий ресурс, то
// необходимо синхронизировать доступ к нему отдельно от замка. Например,
// использовать второй замок или именованную критическую секцию OpenMP.
// Рассмотрим второй вариант.
//
// При этом надо понимать, что нам не гарантируется вывод сообщений "Ожидаю ..."
// только между "Начало ..." и "Конец ...". Поток может не успеть узнать, что
// закрытая секция уже освободилась.
//
void using_lock_with_messages(std::ostream &out) {
  // Локальный замок. Он нужен только для этой задачи. И так будет проще не
  // забыть его уничтожить.
  omp_lock_t lock;
  omp_init_lock(&lock);
 
  #pragma omp parallel
  {
    // Сохраняем номер потока в приватную локальную переменную
    // (она объявлена внутри параллельной секции).
    int thread_num = omp_get_thread_num();
 
    while (!omp_test_lock(&lock)) {
      #pragma omp critical(write_to_out)
      {
        out << "thread " << thread_num << ":\t" //
            << "\tОжидаю закрытую секцию\n";
      }
 
      std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
 
    #pragma omp critical(write_to_out)
    {
      out << "thread " << thread_num << ":\t" //
          << "Начало закрытой секции\n";
    }
 
    // Немного поработаем
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
 
    #pragma omp critical(write_to_out)
    {
      out << "thread " << thread_num << ":\t" //
          << "Конец закрытой секции\n";
    }
 
    omp_unset_lock(&lock);
  }
 
  omp_destroy_lock(&lock);
}
 
void task_2_and_3(std::ostream &out, const Matrix &A) {
  // Локальный замок. Он нужен только для этой задачи. И так будет проще не
  // забыть его уничтожить.
  omp_lock_t lock;
  omp_init_lock(&lock);
 
  #pragma omp parallel
  {
    // Сохраняем номер потока в приватную локальную переменную
    // (она объявлена внутри параллельной секции).
    int thread_num = omp_get_thread_num();
 
    #pragma omp for
    for (size_t i = 0; i < A.rows(); ++i) {
      double min = A[i][0];
      for (size_t j = 1; j < A.cols(); ++j) {
        if (min > A[i][j])
          min = A[i][j];
      }
 
      // Будет выводить только одно сообщение об ожидании
      bool is_error_message_writed = false;
      while (!omp_test_lock(&lock)) {
        if (!is_error_message_writed) {
          #pragma omp critical(write_to_out)
          {
            out << "thread " << thread_num << ":\t" //
                << "\tОжидаю закрытую секцию\n";
          }
          is_error_message_writed = true;
        }
      }
 
      #pragma omp critical(write_to_out)
      {
        out << "thread " << thread_num << ":\t" //
            << "Начало закрытой секции\n";
      }
 
      #pragma omp critical(write_to_out)
      {
        out << "thread " << thread_num << ":\t" //
            << "\trow = " << i << ", \t"        //
            << "min = " << min << "\n";
      }
 
      #pragma omp critical(write_to_out)
      {
        out << "thread " << thread_num << ":\t" //
            << "Конец закрытой секции\n";
      }
 
      omp_unset_lock(&lock);
    }
  }
  omp_destroy_lock(&lock);
}
 
//////////////////////////////////////////////////////////////////////////////
// Следующие константы удобно использовать для задания размеров массивов,
// которые будут равномерно распределены между потоками.
 
// НОК наиболее популярного числа ядер процессора
const size_t lcm_1_2_4_6_8_10_12_16_20 = 240;
// НОК чисел от 1 до 10
const size_t lcm_1___10 = 2520;
// НОК чисел от 1 до 16
const size_t lcm_1___16 = 720720;
// НОК чисел от 1 до 20
const size_t lcm_1___20 = 232792560;
 
int main() {
  const size_t N = lcm_1_2_4_6_8_10_12_16_20;
  const size_t M = 1000;
 
  std::cout << "---------------------------------------------------------\n"
            << " Шаг 1.\n\n";
  Matrix A = random_matrix(N, M);
 
  std::cout << "---------------------------------------------------------\n"
            << " Шаг 2.\n\n";
  min_value_from_row(std::cout, A);
 
  std::cout << "---------------------------------------------------------\n"
            << " Шаг 3.\n\n";
  using_lock_with_messages(std::cout);
 
  std::cout << "---------------------------------------------------------\n"
            << " Шаги 2 и 3.\n\n";
  task_2_and_3(std::cout, A);
 
  return 0;
}