następujący kod powoduje błąd:
Błąd C2661 "std::tuple<std::packaged_task<mala_macierz (long **,long **,long,long,long)>,long **,long **,long,unsigned long,unsigned long>::tuple": brak przeciążonej funkcji przyjmującej 6 argumenty macierze
linia3437 memory -wadliwy kod oznaczyłem znakami komentarz
#include "mnożenie.h"
#include "generator.h"
#include <thread>
#include <vector>
#include <future>
using namespace std;
class join_thread {
vector<thread> temp;
public:
join_thread(vector<thread>& temp_) :temp(temp_) {
}
~join_thread() {
for (auto& i : temp)
if (i.joinable())
i.join();
}
};
mnozenie::mnozenie(long** tab1_, long** tab2_, long rozmiar_):
tab1(tab1_),tab2(tab2_),rozmiar(rozmiar_) {
}
long** mnozenie::mnozenie_wierszami(){
long** tablica= generator(rozmiar, rozmiar, true).tab;
class glowna {
public:
mala_macierz operator()(long** tab1, long** tab2, long rozmiar, long od_, long do_) {
mala_macierz temp = generator(do_ - od_, rozmiar, true);
for (long i = od_; i < do_; i++)
for (long j = 0; j < rozmiar; j++)
for (long k = 0; k < rozmiar; k++)
temp.tab[i][j] = tab1[i][k] * tab2[k][j];
temp.do_ = od_;
temp.do_ = do_;
return temp;
}
};
const unsigned long max_per_thread = 25;
const unsigned long max_thread = ((rozmiar * rozmiar) + max_per_thread - 1) / max_per_thread;
const unsigned long hardware_threads = thread::hardware_concurrency();
const unsigned long num_threads = min(max_thread, (hardware_threads > 0 ? hardware_threads : 0));
const unsigned long block_size = rozmiar / num_threads;
vector<future<mala_macierz>> vec1(num_threads-1);
vector<thread> vec2(num_threads-1);
////////////////////////////////////////////////////////////////////////
join_thread joiner(vec2);
long t;
for (t = 0; t < num_threads-1; t++) {
packaged_task<mala_macierz(long**, long**, long, long, long)> temp{ glowna() };
vec1[t] = temp.get_future();
vec2[t] = thread(temp, tab1, tab2, rozmiar, t * block_size, t * block_size + block_size);
}
////////////////////////////////////////////////////////////////////////////////
mala_macierz ostatnia = glowna()(tab1, tab2, rozmiar, t * block_size, rozmiar);
for (long i = 0; i < num_threads; i++) {
mala_macierz czesc = ((num_threads - 1 == i)?ostatnia:vec1[i].get());
for (long j = czesc.od_,l=0; j < czesc.do_; j++,l++) {
for (long k = 0; k < rozmiar; k++) {
tablica[j][k] = czesc.tab[l][k];
}
}
}
return tablica;
}
long** mnozenie::mnozenie_kolumanami(){
return nullptr;
}
long** mnozenie::mnozenie_kwadratami(){
return nullptr;
}
long** mnozenie::zwykle_mnozenie(){
mala_macierz tab = generator(rozmiar,rozmiar, true);
for (long i = 0; i < rozmiar; i++)
for (long j = 0; j < rozmiar; j++)
for (long k = 0; k < rozmiar; k++)
tab.tab[i][j]+= tab1[i][k] * tab2[k][j];
return tab.tab;
}
long** mnozenie::daj_macierz1(){
return tab1;
}
long** mnozenie::daj_macierz2(){
return tab2;
}
void mnozenie::zmien_macierz1(long** tab1_){
tab1 = tab1_;
}
void mnozenie::zmien_macierz2(long** tab2_){
tab2 = tab2_;
}
long mnozenie::daj_rozmiar(){
return rozmiar;
}
void mnozenie::zmien_rozmiar(long rozmiar_){
rozmiar = rozmiar_;
}