0 w kolumnach równoległe mnożenie macierzy

Question

#include "macierz.h"
#include "generator_macierzy.h"
#include <thread>
#include <iostream>
#include <future>
#include <iomanip>
#include <atomic>
#include <Windows.h>

using namespace std;

class join_thread {
	vector<thread>& temp;
public:
	join_thread(vector<thread>& temp_) :temp(temp_) {
	}
	~join_thread() {
		for (auto& t : temp)
			if (t.joinable())
				t.join();
	}
};

mnorzenie::mnorzenie(long** p, long** d,long r):macierz1(p),macierz2(d),rozmiar(r){
	wynik = generator(r, true);
}

void mnorzenie::ustaw_pierwsza_macierz(long** temp){
	macierz1 = temp;
}

void mnorzenie::ustaw_druga_macierz(long** temp){
	macierz2 = temp;
} 

void mnorzenie::ustaw_szerokosc(long sz){
	rozmiar = sz;
}

void mnorzenie::mnorzenie_wierszy() {

	class glowna {
	public:

		void operator()(long od_, long do_, long** tab1, long** tab2, long** docelowa,
			long rozmiar, atomic<bool>& flaga, exception_ptr& except) {
			try {
				for (long i = od_; i < do_; i++) 
					for (long j = 0; j < rozmiar; j++) 
						for (long k = 0; k < rozmiar; k++)
							docelowa[i][j] += tab1[i][k] * tab2[j][k];
				
			}
			catch (exception& temp) {
				flaga = true;
				except = current_exception();
			}
		}
	};
	unsigned long const min_per_thread = 25;
	unsigned long const size = rozmiar * rozmiar;
	unsigned long const hardware_threads = thread::hardware_concurrency();
	unsigned long const max_threads = min(
		(hardware_threads > 0 ? hardware_threads : 2),
		(size + min_per_thread - 1) / min_per_thread);
	unsigned long const count = rozmiar / max_threads;
	exception_ptr wsk=nullptr;
	vector<thread> wektor(max_threads-1);
	atomic<bool> flaga = false;
	long i;
	{
		join_thread joiner(wektor);
		for (i = 0; (i < (max_threads - 1))&&!flaga; i++) {
//////////////////////////////////////////////////////////////////////////////////////////////////////
			wektor[i]=thread(([&]() {
				glowna()(i * count, i * count + count, macierz1, macierz2, wynik, rozmiar, flaga, wsk); }));
		////////////////////////////////////////////////////////////////////////////////////////////
}

		if(!flaga)
		glowna()(i * count, rozmiar, macierz1, macierz2, wynik, rozmiar, flaga, wsk);
	}
	if (flaga)
		throw wsk;
}


void mnorzenie::mnorzenie_kolumn(){

}

void mnorzenie::mnorzenie_kwadratow(){

}

void mnorzenie::nolmalne_mnorzenie(){
	
	for (long i = 0; i < rozmiar; i++) {
		for (long j = 0; j < rozmiar; j++) {
			for (long k = 0; k < rozmiar; k++)
				wynik[i][j] += macierz1[i][k] * macierz2[j][k];
		}
	}
	
}
long** mnorzenie::daj_macierz() {
	return wynik;
}

Wszystko wykonuje się dobrze ale nie współbieżnie gdy dziele zadania na wątki pierwsze sześć kolumn wypełnia się zerami linijka powodująca ten błąd została oznaczona znakami komentarz

Comments

Błędu w kodzie nie widzę, ale nie rozumiem sensu klasy glowna. Skoro używasz lambdy, to sens tej klasy jest żaden, niepotrzebnie zaciemnia kod. A jeśli z jakichś powodów klasa musi być, wtedy daj wątkowi obiekt tejże przekazując niezbędne parametry w konstruktorze, a operator() niech będzie bezparametrowy.

Następna rzecz to ta obsługa wyjątku. Po co, skoro nie ma tam nic, co rzuciłoby wyjątek, który blok try...catch mogłoby wyłapać?

---

@RufinB, W linii 51 i 101 nie powinno być jakoś tak:

 docelowa[i][j] += tab1[i][k] * tab2[k][j];

O ile pamiętam, przy mnożeniu macierzy w jednej macierzy leci się po wierszu a w drugiej po kolumnie.

Wszędzie przekazujesz podwójny wskaźnik, więc macierz musi być w postaci tablicy wskaźników na wiersze - allokowana wierszami.