multithreading and parameters mixup - c

Question

I have a function which behaves correctly when called by a single thread (either by calling it directly, or via CreateThread() / WaitForSingleObject() calls ), but seems to go haywire when invoked by multiple CreateThread() followed by a WaitForMultipleObject() call.
From the extensive debugging I have tried, It looks as if some of the variables passed as parameters to the main function being called are not kept isolated between different threads, and instead use the same address space (example below). Here's a summary with some details of the problem:
First, I define a type to hold all the parameters for the function every thread needs to call:
typedef struct {
tDebugInfo DebugParms; int SampleCount; double** Sample; double** Target; double** a; double** F; double** dF; double** prevF; double** prevdF; double*** W; double*** prevW; double*** prevdW; double* e; double* dk; double* dj; double* dj2; double* sk; double* sk2; double* adzev21; double* prevadzev21; double** UW10; double* ro10e; double** dW10d; double** A; double** B; double** C; double** D; double** E; double** G; double** ET; double** AB; double** ABC; double** ABCD; double** ABCDE; double** ABCDH; double** ABCDHG; double** SABCDE; double** SABCDHG; double** I; double** J; double** M; double** x; double** xT; double* xU; double** dW10; int DataSetId; int TestId; int PredictionLen; double* Forecast; double ScaleM; double ScaleP; NN_Parms* ElmanParms; int DP[2][10];} tTrainParams;
I then allocate an array of structures to hold each thread's set of parameters:
HANDLE* HTrain = (HANDLE*)malloc(DatasetsCount*sizeof(HANDLE));
tTrainParams* tp = (tTrainParams*)malloc(DatasetsCount * sizeof(tTrainParams));
DWORD tid = 0; LPDWORD th_id = &tid;
Then, I set function parameters for each thread:
tp[d].ElmanParms = pElmanParams; tp[d].SampleCount = SampleCount; tp[d].Sample = SampleData_Scaled[d]; tp[d].Target = TargetData_Scaled[d]; tp[d].a = a; tp[d].F = F; tp[d].dF = dF; tp[d].prevF = prevF; tp[d].prevdF = prevdF; tp[d].W = W; tp[d].prevW = prevW; tp[d].prevdW = prevdW; tp[d].e = e; tp[d].dk = dk; tp[d].dj = dj; tp[d].dj2 = dj2; tp[d].sk = sk; tp[d].sk2 = sk2; tp[d].adzev21 = adzev21; tp[d].prevadzev21 = prevadzev21; tp[d].UW10 = UW10; tp[d].ro10e = ro10e; tp[d].dW10d = dW10d; tp[d].A = A; tp[d].B = B; tp[d].C = C; tp[d].D = D; tp[d].E = E; tp[d].G = G; tp[d].ET = ET; tp[d].AB = AB; tp[d].ABC = ABC; tp[d].ABCD = ABCD; tp[d].ABCDE = ABCDE; tp[d].ABCDH = ABCDH; tp[d].ABCDHG = ABCDHG; tp[d].SABCDE = SABCDE; tp[d].SABCDHG = SABCDHG; tp[d].I = I; tp[d].J = J; tp[d].M = M; tp[d].x = x; tp[d].xT = xT; tp[d].xU = xU; tp[d].dW10 = dW10; tp[d].DebugParms = pDebugParms; tp[d].ElmanParms = pElmanParams; tp[d].PredictionLen = pPredictionLen; tp[d].Forecast = ForecastData[d]; tp[d].ScaleM = ScaleM[d]; tp[d].ScaleP = ScaleP[d]; tp[d].TestId = pTestId; tp[d].DataSetId = d;
Then, I call a wrapper function GetForecastFromTraining(tTrainParams* parms) for each thread, having set in advance the relevant parameters in the "tp" structure array:
HTrain[d] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)GetForecastFromTraining, &tp[d], 0, th_id);
Finally, I call WaitForMultipleObjects():
WaitForMultipleObjects(DatasetsCount, HTrain, TRUE, INFINITE);
What happens inside GetForecastFromTraining() for most variables (apparently arrays only) is that whenever one thread changes the value of one array element (say, W[0][0][0]), the new value becomes current inside all the other threads, too. This, of course, screws up all the calculations that are being made across all threads, and looks to me to be contrary to the whole segregation story across threads.
One hint of what's going on is that, when I look at "Parallel Watch" debugging window inside VS2013, I see that W has the same address across all the threads (hence the same values); however, &W is different for each thread. Other non-array variables seem to behave fine. Finally, I double-checked the /MTd flag in the compiler option, and it is there.
I'm quite lost on this. Any suggestion?
P.S.: Here is a streamlined version of my program, which displays the same problematic behaviour. In this example, breaking the execution after the Sleep(1000) line shows that a1, a2 and G variables each correctly contains the thread id, while F is the same for all threads.
#include <Windows.h>
#include <stdio.h>
#define MAX_THREADS 5
HANDLE h[MAX_THREADS];
typedef struct{
int a1;
int a2;
double* F;
double G[5];
} tMySumParms;
void MySum(tMySumParms* p){
int tid = GetCurrentThreadId();
Sleep(200);
p->a1 = tid;
p->a2 = -tid;
p->F[0] = tid;
p->F[1] = -tid;
p->G[0] = tid;
p->G[1] = -tid;
Sleep(1000);
}
extern "C" __declspec(dllexport) int GetKaz(){
LPDWORD t = NULL;
tMySumParms* p = (tMySumParms*)malloc(MAX_THREADS*sizeof(tMySumParms));
HANDLE* h = (HANDLE*)malloc(MAX_THREADS*sizeof(HANDLE));
double G[5];
double* F = (double*)malloc(5 * sizeof(double));
for (int i = 0; i < MAX_THREADS; i++){
p[i].a1 = 1;
p[i].a2 = 2 ;
p[i].F = F;
memcpy(p[i].G, G, 5 * sizeof(double));
h[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)MySum, &p[i], 0, t);
}
WaitForMultipleObjects(MAX_THREADS, h, TRUE, INFINITE);
return 0;
}

Answer 1

W is declared as double*** in the parameter struct, later in the question you say you use it as W[0][0][0]. So W is an array of pointers to arrays of pointers to arrays of doubles.
My guess is that one of those layers is common for all threads.
To confirm this theory, and to make sure it is not a concurrency problem but a data structure problem, I would create a simple single-threaded test function as follows:
Fill the array intended for thread 1 with 1.0
Then fill the array for thread 2 with 2.0
Check the values for thread 1.
The streamlined version shows the problem: The F array is allocated once and each thread gets a pointer to this single array. So if one thread updates the array, all the others see the changes.
double* F = (double*)malloc(5 * sizeof(double)); // one array!
for (int i = 0; i < MAX_THREADS; i++){
...
p[i].F = F; // all threads use the same array!
Change it to:
for (int i = 0; i < MAX_THREADS; i++){
...
p[i].F = malloc(5 * sizeof(double)); // each thread has its own array