c ++中的线程，在2d数组中找到最大的条目

Question

I'm having some trouble finding the largest entry in a 2d array with a threaded function. I've been glued to the screen for hours now, and I could use some help.

Here is the code:

#include <iostream>
#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <random>
#include <ctime>
#include <future>
#include <thread>

using namespace std;

// A vanilla random number generator
double genRandNum(double min, double max){

  return min + (rand() / (RAND_MAX / (max - min)));

}

double get_wallTime() {
    struct timeval tp;
    gettimeofday(&tp, NULL);
    return (double) (tp.tv_sec + tp.tv_usec/1000000.0);
} 

void getLargest(double** anArray, double largestEntry, int dimLower, int dimUpper, int dim) {

    for (int i = dimLower; i < dimUpper; i++) {
        for (int  j = 0; j < dim; j++) {
            if (anArray[i][j] > largestEntry) {
                largestEntry = anArray[i][j]; 
            }
        }
    }

}

// Main routine
int main(){

  // Seed the random number generator
  srand( time(NULL));

  // 2D array dimension
  int dim = 30000;

  // Specify max values
  double max = (double) (dim * dim * dim);
  double min = (double) (dim * dim * dim * -1.0);

  double t1 = get_wallTime();
  // Create a 2D array
  double **myArray = new double*[dim];
  for (int i=0; i<dim; i++){
    myArray[i] = new double[dim];
    for (int j=0; j<dim; j++){
      // generate random number
      myArray[i][j] = genRandNum(min, max);
    }
  }

  double largestEntry = 0.0;
  double largestEntry2 = 0.0;
  double largestEntry3 = 0.0;
  double largestEntry4 = 0.0;
  double largestEntry5 = 0.0;
  int portion = dim / 5;
  std::future<void> thread1 = std::async (std::launch::async, getLargest, myArray, largestEntry, 0, portion, dim);

  std::future<void> thread2 = std::async (std::launch::async, getLargest, myArray, largestEntry2, portion, (portion * 2), dim);

  std::future<void> thread3 = std::async (std::launch::async, getLargest, myArray, largestEntry3, (portion * 2), (portion * 3), dim);

  std::future<void> thread4 = std::async (std::launch::async, getLargest, myArray, largestEntry4, (portion * 3), (portion * 4), dim);

  std::future<void> thread5 = std::async (std::launch::async, getLargest, myArray, largestEntry5, (portion *4), dim, dim);
  thread1.get();
  thread2.get();
  thread3.get();
  thread4.get();

  thread5.get();


  if (largestEntry2 > largestEntry) {
     largestEntry = largestEntry2;
  } 
  if (largestEntry3 > largestEntry) {
    largestEntry = largestEntry3;
  }
  if (largestEntry4 > largestEntry) {
    largestEntry = largestEntry4;
  }
  if (largestEntry5 > largestEntry) {
    largestEntry = largestEntry5;
  }

  double t2 = get_wallTime();
  double t3 = t2 - t1;

  cout << " The largest entry is " << largestEntry << endl;  

  cout << "runtime : " <<  t3 << "\n";
}

I believe I'm setting everything up correctly, but I've just learned how to use async so I'm sure something is incorrect. When run, I get zero as the output of the largest entry, which is wrong, and I get a runtime much longer than I'm expecting.

Here is the output:

 The largest entry is 0
runtime : 13.8261

I think I'm passing in largestEntry to the threaded function incorrectly, but I have no idea how to fix it. The threaded function, getLargest , is supposed to find the largest entry of the array it's provided, and when I create the threads I assign each of them a portion of the array.

Any advice anyone could provide would be much appreciated.

Answer 1

Currently you are just changing the value of the local largestEntry parameter. This will not change anything in the calling program.

One solution is to pass in largestEntry as a reference (change your function to say double &largestEntry in its parameter list)

Note that this has nothing to do with threading, you could just call your function normally to test it.

Edit: I had trouble with using a reference when I tried it (could just be a old compiler) - if references don't work, you could always pass the largestEntry as a pointer - double *largestEntry in the function parameter list and a few * and & placed in the rest of the code.

Answer 2

The problem has been described in the last answer by The Dark. However, i find the solution not ideal. For me, it would be more logical that your function returned the value thus found rather than write it in a parameter.

That way you can use the get() function of the future to obtain the answer when the threads are finished, and you do not use references or pointers where it is really not needed.

Note: simply using a reference would not work here because the parameter to std::async are copied, the same way as for std::thread . If you want it to work with a reference, you need to use std::ref ( link ) in that case.