Member Avatar for denizen08
denizen08 0 Newbie Poster

I have a project that requires us to perform matrix multiplication via multi-threading, using the Windows API.

I've got the basic code running and everything is well under sane/ideal conditions. But if my input matrices go beyond 10x10 the program ends up failing on WaitOnMultipleObjects(...) and runs the main thread through without waiting for the rest to complete computation.

My solution computes for each element of the resultant matrix. Below is the code:

Attached are the rest of my source files in case you want to compile it.

#include "stdafx.h"
#include <cstdlib>
#include <iostream>
#include <Windows.h>
#include <process.h>
#include <strsafe.h>
#include "random.h"

using namespace std;

class Matrix {
private:
  double **_matrixValues;
  unsigned int _rowSize, _columnSize;

public:
  Matrix() {
    _rowSize = 0;
    _columnSize = 0;
    _matrixValues = 0;
  }
  Matrix(const unsigned int row_size, const unsigned int column_size) {
    _rowSize = row_size;
    _columnSize = column_size;
    _matrixValues = (double**)malloc(sizeof(double*)*_rowSize);
    for(unsigned int i =0 ; i <_rowSize;i++){
      *(_matrixValues+i) = (double*)malloc(sizeof(double)*_columnSize);
      for(unsigned int j = 0; j < _columnSize; ++j) {
        _matrixValues[i][j] = 0;
      }
    }
  }
  /*~Matrix() {
    for(int i = 0; i < _rowSize; i++)
		  free(_matrixValues[i]);
    free(_matrixValues);
    _rowSize = 0;
    _columnSize = 0;
  }*/
  double getValue_at (const unsigned int row_index,
    const unsigned int column_index){
    if(row_index >= _rowSize || column_index >= _columnSize)
      cerr << "[GETTER]Access Violation: Out of Bounds";
    else
      return _matrixValues[row_index][column_index];
  }
  void setValue_at (double value, const unsigned int row_index,
    const unsigned int column_index) {
    if((row_index >= _rowSize) || (column_index >= _columnSize))
       cerr << "[SETTER]Access Violation: Out of Bounds";
    else
      _matrixValues[row_index][column_index] = value;
  }
  const unsigned int ColumnSize() { return _columnSize; }
  const unsigned int RowSize() { return _rowSize; }
};

typedef struct ThreadedMatrixData {
  Matrix *A, *B, *resultantMatrix;
  unsigned int row_position, column_position;
  DWORD theadId;
} ThreadedMatrixComputationData, *ThreadedMatrixComputationDataPtr;


#define MAX_THREADS 3
#define BUF_SIZE 1024

DWORD WINAPI ThreadedMultiplier( LPVOID lpParam );
void ErrorHandler(LPTSTR lpszFunction);

void print_usage();

void randomMatrixFill(Matrix &matrix);
Matrix ThreadedMatrixMultiplier(Matrix &leftHandMatrix, Matrix &rightHandMatrix);

int main(int argc, char* argv[])
{
	const int a_row = 10, a_column = 4;
	const int b_row = 4, b_column = 10;
	Matrix A, B;

  A = Matrix(a_row,a_column);
  B = Matrix(b_row,b_column);
  printf("Generating randomized matrices:\n");
  randomMatrixFill(A);
  randomMatrixFill(B);

  printf("\tA:\n");
  for(int i = 0; i < a_row; ++i) {
    printf("\t");
    for(int j = 0; j < a_column; ++j) {
      printf("%f ", A.getValue_at(i,j));
    }
    printf("\n");
  }
  printf("\tB:\n");
  for(int i = 0; i < b_row; ++i) {
    printf("\t");
    for(int j = 0; j < b_column; ++j) {
      printf("%f ", B.getValue_at(i,j));
    }
    printf("\n");
  }

  printf("Performing threded Matrix Multiplication...\n");
  Matrix C = ThreadedMatrixMultiplier(A,B);
  printf("\nResultant Matrix C:\n");
  
  for(unsigned int i = 0; i < C.RowSize(); ++i) {
    printf("\t");
    for(unsigned int j = 0; j < C.ColumnSize(); ++j) {
      printf("%f ", C.getValue_at(i,j));
    }
    printf("\n");
  }

  system("PAUSE");
	return 0;
}


void randomMatrixFill(Matrix &matrix){
  RandNumGen X (-10.0, 10.0); // random coefs in range (-10,10)
  for (unsigned int i=0; i < matrix.RowSize(); i++) {
    for (unsigned int j=0; j < matrix.ColumnSize(); j++) {
      matrix.setValue_at(X.generate(),i,j);
    }
  }
}


Matrix ThreadedMatrixMultiplier(Matrix &leftHandMatrix, Matrix &rightHandMatrix) {
   //prepare new resultant matrix parameters
  unsigned int returnValue_rowSize, returnValue_columnSize;
  if(leftHandMatrix.ColumnSize() > rightHandMatrix.ColumnSize())
    returnValue_columnSize = leftHandMatrix.ColumnSize();
  else
    returnValue_columnSize = rightHandMatrix.ColumnSize();
  if(leftHandMatrix.RowSize() > rightHandMatrix.RowSize())
    returnValue_rowSize = leftHandMatrix.RowSize();
  else
    returnValue_rowSize = rightHandMatrix.RowSize();
  Matrix returnValue = Matrix(returnValue_rowSize, returnValue_columnSize);

  const unsigned int totalThreads = returnValue_rowSize*returnValue_columnSize;

  //prepare data and handlers for computation
  ThreadedMatrixComputationDataPtr *threadedMatrixComputationData;
  threadedMatrixComputationData = new ThreadedMatrixComputationDataPtr[totalThreads];
  DWORD *dwThreadIdArray;
  dwThreadIdArray = new DWORD[totalThreads];
  HANDLE *hThreadArray;
  hThreadArray = new HANDLE[totalThreads];
  HANDLE *hThreadHandleAssertie;  
  hThreadHandleAssertie = new HANDLE[totalThreads];
  
  printf("Creating %d threads to handle a %dx%d Matrix",
    totalThreads, returnValue_rowSize,returnValue_columnSize);

  // Allocate memory for thread data.
  for(unsigned int i = 0; i < totalThreads; i++) {
    threadedMatrixComputationData[i] = (ThreadedMatrixComputationDataPtr) HeapAlloc(
      GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ThreadedMatrixComputationData) );
    
    if( threadedMatrixComputationData[i] == NULL ) {
        // If the array allocation fails, the system is out of memory
        // so there is no point in trying to print an error message.
        // Just terminate execution.
        ExitProcess(2);
    }

    // Provide references to data for each thread to work with.
    threadedMatrixComputationData[i]->A = &leftHandMatrix;
    threadedMatrixComputationData[i]->B = &rightHandMatrix;
    threadedMatrixComputationData[i]->resultantMatrix = &returnValue;
    threadedMatrixComputationData[i]->column_position = i%returnValue_columnSize;
    threadedMatrixComputationData[i]->row_position = i/returnValue_columnSize;
    // Time to actually create the thread to begin execution on its own, bitch.

    hThreadArray[i] = CreateThread( 
        NULL,                   // default security attributes
        0,                      // use default stack size  
        ThreadedMultiplier,       // thread function name
        threadedMatrixComputationData[i],          // argument to thread function 
        0,                      // use default creation flags | run immediately
        &dwThreadIdArray[i]);   // returns the thread identifier

    threadedMatrixComputationData[i]->theadId = dwThreadIdArray[i];
    
    // Check the return value for success.
    // If CreateThread fails, terminate execution. 
    // This will automatically clean up threads and memory. 

    if (hThreadArray[i] == NULL) {
        ErrorHandler(TEXT("CreateThread"));
        ExitProcess(3);
    } else {
      printf("\t->Launched Thread# %d, ID:%d\n", i, dwThreadIdArray[i]);
      //WaitForSingleObject(hThreadArray[i], INFINITE); //waiting for each thread would solve the problem, but defeat the purpose of using multiple threads. A simple, but obviously wrong work-around.
    }
  } // End of multiplier thread creation loop.
  
  DWORD res = WaitForMultipleObjects(totalThreads, hThreadArray, TRUE, INFINITE);
  
  // Close all thread handles and free memory allocations.
  // House cleaning after the thread parties! FTW.
  //for(unsigned int i=0; i<totalThreads; i++) {
  //    CloseHandle(hThreadArray[i]);
  //    if(threadedMatrixComputationData[i] != NULL) {
  //        HeapFree(GetProcessHeap(), 0, threadedMatrixComputationData[i]);
  //        threadedMatrixComputationData[i] = NULL;    // Ensure address is not reused.
  //    }
  //}
  return returnValue;
}

DWORD WINAPI ThreadedMultiplier( LPVOID lpParam ) { 
  HANDLE hStdout;
  ThreadedMatrixComputationDataPtr threadedMatrixComputationDataInstance;

  TCHAR msgBuf[BUF_SIZE];
  size_t cchStringSize;
  DWORD dwChars;

  // Make sure there is a console to receive output results. 

  hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
  if( hStdout == INVALID_HANDLE_VALUE )
      return 1;

  // Cast the parameter to the correct data type.
  // The pointer is known to be valid because 
  // it was checked for NULL before the thread was created.
 
  threadedMatrixComputationDataInstance = (ThreadedMatrixComputationDataPtr)lpParam;
  unsigned int leftHandSideOperandBound = threadedMatrixComputationDataInstance->A->ColumnSize();
  unsigned int rightHandSideOperandBound = threadedMatrixComputationDataInstance->B->RowSize();
	double product = 0;
  for (unsigned int i=0; i<leftHandSideOperandBound; i++) {
    // leftHandSideMatrix only requires access to a single row span
    for(unsigned int j=0; j<rightHandSideOperandBound; j++) {
    // rightHandSideMatrix only requires access to a single column span
      product +=
        threadedMatrixComputationDataInstance
        ->A->getValue_at(threadedMatrixComputationDataInstance->row_position,i) * 
        threadedMatrixComputationDataInstance
        ->B->getValue_at(j,threadedMatrixComputationDataInstance->column_position);
    }
  }
	threadedMatrixComputationDataInstance->resultantMatrix->setValue_at(product,
    threadedMatrixComputationDataInstance->row_position,
    threadedMatrixComputationDataInstance->column_position);

  // Print the parameter values using thread-safe functions.
  StringCchPrintf(msgBuf, BUF_SIZE, TEXT("[%d]Finished computation at new matrix position: A(%d,-)xB(-,%d) -> C(%d, %d)\n"), 
    threadedMatrixComputationDataInstance->theadId,
    threadedMatrixComputationDataInstance->row_position,
    threadedMatrixComputationDataInstance->column_position,
    threadedMatrixComputationDataInstance->row_position,
    threadedMatrixComputationDataInstance->column_position); 
  StringCchLength(msgBuf, BUF_SIZE, &cchStringSize);
  WriteConsole(hStdout, msgBuf, (DWORD)cchStringSize, &dwChars, NULL);

  return 0;
} 

void ErrorHandler(LPTSTR lpszFunction) 
{ 
    // Retrieve the system error message for the last-error code.

    LPVOID lpMsgBuf;
    LPVOID lpDisplayBuf;
    DWORD dw = GetLastError(); 

    FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
        FORMAT_MESSAGE_FROM_SYSTEM |
        FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL,
        dw,
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
        (LPTSTR) &lpMsgBuf,
        0, NULL );

    // Display the error message.

    lpDisplayBuf = (LPVOID)LocalAlloc(LMEM_ZEROINIT, 
        (lstrlen((LPCTSTR) lpMsgBuf) + lstrlen((LPCTSTR) lpszFunction) + 40) * sizeof(TCHAR)); 
    StringCchPrintf((LPTSTR)lpDisplayBuf, 
        LocalSize(lpDisplayBuf) / sizeof(TCHAR),
        TEXT("%s failed with error %d: %s"), 
        lpszFunction, dw, lpMsgBuf); 
    MessageBox(NULL, (LPCTSTR) lpDisplayBuf, TEXT("Error"), MB_OK); 

    // Free error-handling buffer allocations.

    LocalFree(lpMsgBuf);
    LocalFree(lpDisplayBuf);
}
//filename: random.cpp
//author: Luisito L. Agustin
//
// random.cpp:
//   implements random_number_generator class
//   specified in random.h
//
#include "stdafx.h"
#include <cstdlib>
#include <iostream>
#include <ctime>
#include "random.h"
using namespace std;

random_number_generator::random_number_generator()
{
  srand(time(NULL));
  _min = 0.0;
  _max = 1.0;
}

random_number_generator::
  random_number_generator(double min, double max)
{ 
  srand(time(NULL));                                 
  _min = min;
  _max = max;
}  

double random_number_generator::generate()
{
  double scale = 0.0;
  for (int i=1; i<=4; i++)
    scale = (scale + rand())/(RAND_MAX+1);
  // scale would be in the range (0,1)     
  return (_min + scale * (_max - _min));
}  

double altRandNumGen::generate()
{
  double scale = 1.0;       
  for (int i=1; i<=4; i++)
  {
    scale = scale *( -1.0 + (2.0*rand())/RAND_MAX );
  // scale would be in the range (-1,1)  
//    cout << "scale: " << scale << endl;
  }
  return (_min + (scale+1.0) * (_max - _min)/2.0);
}
//filename: random.h
//author: Luisito L. Agustin
//
// random.h:
//   contains interface for random_number_generator class
//            
#ifndef RANDOM_H
#define RANDOM_H 1
/*
constructors:
    random_number_generator();
      // default: random number generator
      // generates nos. in the range [0.0,1.0]
      usage:
        random_number_generator x;
        // x is a random number generator that
        // generates nos. in the range [0.0,1.0]   
    random_number_generator(double min, double max);  
      // random number generator
      // generates nos. in the range [min,max]
      usage:
        random_number_generator x(-1.0,1.0);
        // x is a random number generator that
        // generates nos. in the range [-1.0,1.0]   
random number generation:
    double generate();  
      // generate a random no. in the specified range
      usage:
        random_number_generator x(-1.0,1.0);
        x.generate();
        double y = x.generate();
        // x is a random number generator that
        // generates nos. in the range [-1.0,1.0]  

*/

class random_number_generator 
{
  public:
    random_number_generator();
      // default: random number generator
      // generates nos. in the range [0.0,1.0]
    random_number_generator(double min, double max);  
      // random number generator
      // generates nos. in the range [min,max]
    double generate();  
      // generate a random no. in the specified range
  protected:
    double _min;
    double _max;        
};

class RandNumGen : public random_number_generator  
{
  public:
    RandNumGen()
      :random_number_generator(){}
      // default: random number generator
      // generates nos. in the range [0.0,1.0]
    RandNumGen(double min, double max)
      :random_number_generator(min, max){}  
      // random number generator
      // generates nos. in the range [min,max]
};

class altRandNumGen :public random_number_generator  
{
  public:
    altRandNumGen() 
      :random_number_generator(){}
      // default: random number generator
      // generates nos. in the range [0.0,1.0]
    altRandNumGen(double min, double max)
      :random_number_generator(min, max){}  
      // random number generator
      // generates nos. in the range [min,max]
    double generate();  
      // generate a random no. in the specified range
};




#endif
// stdafx.cpp : source file that includes just the standard includes
// OS_PROJECT1.pch will be the pre-compiled header
// stdafx.obj will contain the pre-compiled type information

#include "stdafx.h"

// TODO: reference any additional headers you need in STDAFX.H
// and not in this file
// stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently, but
// are changed infrequently
//

#pragma once

#include "targetver.h"

#include <stdio.h>
#include <tchar.h>



// TODO: reference additional headers your program requires here
#pragma once

// Including SDKDDKVer.h defines the highest available Windows platform.

// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and
// set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h.

#include <SDKDDKVer.h>
Edited by denizen08 because: n/a
  • 1 Contributor
  • 0 Replies
  • 121 Views
Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.