Многопоточное матрично-векторное произведение

// ConsoleApplication7.cpp: определяет точку входа для консольного приложения.
//
 
#include "stdafx.h"
#include <iostream>
#include <boost/asio/io_service.hpp>
#include <boost/bind.hpp>
#include <boost/thread/thread.hpp>
 
 
void NTAPI MyWorkCallback(PTP_CALLBACK_INSTANCE instance, void * context, PTP_WORK work)
{
    char* p= *((char**)context);
    printf("Hello %s", p);
    printf("\n");
}
 
 
int _tmain(int argc, _TCHAR* argv[])
{
    char mas1[]= "1";
    char mas2[]= "2";
    char* p1= mas1;
    char** p= &p1;
   TP_WORK * work = CreateThreadpoolWork(MyWorkCallback, p, NULL);
    if (work == NULL)
        printf("Error %d in CreateThreadpoolWork", GetLastError());
    else {
        SubmitThreadpoolWork(work);
        WaitForThreadpoolWorkCallbacks(work, FALSE);
        SubmitThreadpoolWork(work);
        p1=mas2;
        SubmitThreadpoolWork(work);
        WaitForThreadpoolWorkCallbacks(work, FALSE);
        CloseThreadpoolWork(work);
    }
 
 
    char ch;
    std::cout<<*p;
    std::cin>>ch;
    return 0;
}

#include "stdafx.h"
#include <iostream>
#include <windows.h>
 
CRITICAL_SECTION crSect1;
 
 
void NTAPI MyWorkCallback(PTP_CALLBACK_INSTANCE instance, void * context, PTP_WORK work)
{
 
    EnterCriticalSection(&crSect1);
  static int yy=-1;
  ++yy;
  LeaveCriticalSection(&crSect1);
    char** p= (char**)context;
    printf("Hello %s", p[yy]);
    printf("\n");
}
 
 
int _tmain(int argc, _TCHAR* argv[])
{
    InitializeCriticalSection(&crSect1);
    char mas1[]= "1";
    char mas2[]= "2";
    char* p[2];
    p[0]= mas1;
    p[1]= mas2;
   TP_WORK * work = CreateThreadpoolWork(MyWorkCallback, p, NULL);
    if (work == NULL)
        printf("Error %d in CreateThreadpoolWork", GetLastError());
    else {
        SubmitThreadpoolWork(work);
        SubmitThreadpoolWork(work);
        WaitForThreadpoolWorkCallbacks(work, FALSE);
        CloseThreadpoolWork(work);
    }
 
 DeleteCriticalSection(&crSect1);
    char ch;
    std::cout<<*p;
    std::cin>>ch;
    return 0;
}

struct DATA_MATVEC
{
 DATA_MATVEC():MATR(0),VEC(0),REZ(0),nP(0){
                             InitializeCriticalSection(&crSect);
                             fWork = CreateThreadpoolWork(MyWorkCallback_MatVec, this, NULL);
                            };
 ~DATA_MATVEC() {
              DeleteCriticalSection(&crSect);
              CloseThreadpoolWork(fWork);
             };
 
 size_t nP;
 MATRIXX_LENTA<double>* MATR;    //Ленточная матрица - исходная
 VECTOR<double>* VEC;            //Множитель
 VECTOR<double>* REZ;            //Произведение
 CRITICAL_SECTION crSect;
 TP_WORK* fWork;
};
typedef DATA_MATVEC* PDATA_MATVEC;
 
static DATA_MATVEC mMatVec;      //Через этот экземпляр структуры происходит координация запусков MyWorkCallback_MatVec

void NTAPI MyWorkCallback_MatVec(PTP_CALLBACK_INSTANCE instance, void * context, PTP_WORK work)
{
 PDATA_MATVEC data= (PDATA_MATVEC)context;
 size_t nP= data->nP;
 CRITICAL_SECTION* crSect1= &(data->crSect);
 MATRIXX_LENTA<double>& MATR= *(data->MATR);
 VECTOR<double>& REZ= *(data->REZ);
 VECTOR<double>& VEC= *(data->VEC);
 size_t num= MATR.num;
 
  EnterCriticalSection(crSect1);      //Чтобы при последующих запусках MyWorkCallback_MatVec обрабатывался следующий кусок матрицы
  static size_t iP=-1;
  static size_t iN=0;
  ++iP;
  if(iP==0) REZ=0;
  size_t iPP=iP;
  LeaveCriticalSection(crSect1);
 
  size_t nnn= MATR.num/nP;
  size_t nnnL= MATR.num- (nP-1)*nnn;
  size_t numL;
 
  //Здесь вычисления для куска матрицы
 
 EnterCriticalSection(crSect1);
 ++iN;
 if(iN==nP){ iP=-1; iN=0;};               //Обнуление счетчика
 LeaveCriticalSection(crSect1);
};

template <typename T>
 void MATRIXX_LENTA<T>::multiply_MatVecPool(VECTOR<T>& vec, VECTOR<T>& REZ, int nP)
 {
  mMatVec.MATR= this;
  mMatVec.VEC= &vec;
  mMatVec.REZ= &REZ;
  mMatVec.nP= nP;
 
     for(int i=0; i<nP; ++i) SubmitThreadpoolWork(mMatVec.fWork);
     WaitForThreadpoolWorkCallbacks(mMatVec.fWork, FALSE);
 
  return;
 };