Przesyłanie tablicy 2D na GPU + MPI

0

Witam, próbowałem już na różne sposoby, ale wciąż mi nie wychodzi. Przydałby mi się świeży pomysł, mianowicie chodzi o to aby przesłać tablicę **T_last na GPU. Już staram się wytłumaczyć o co chodzi.

Na początku deklaruję tablicę 2D w ten sposób

float **T_last = new float * [local_NY]; 	// T - 1
float **T = new float * [local_NY]; 		// T

Później określam przestrzeń dla lokalnej tablicy (tworzę dodatkowe kolumny dla overlappingu, lokalne tablice wymieniają dane między sobą)

T_last= (float**) malloc(sizeof(float*) * local_NY);
	for (i = 0; i < local_NY; i++) {
		T_last[i] = (float*) malloc(sizeof(float) * (local_NX + 2));
	}
T = .... (jest robiona na tej samej zasadzie)

Inicjalizacja lokalnej siatki, wypelnienie liczbami od 0 do 1

for (i = 0; i < local_NY; i++) {
	for (j = 1; j < local_NX + 2; j++) {
		T[i][j] = (int) rand() % 2;
	}
}

Stworzenie buferow do przekazywania wartosci itd.
Następnie wchodzimy w petle, w której następuje wymiana kolumn, aktualne wartości z tablicy sa kopiowane do starej tablicy, kazdy proces oblicza swoja lokalna tablice (nie wiem czy wrzucać cały kod, ewentualnie wyedytuje).

Dochodze do momentu, w którym jest podział, każdy proces ma swoją lokalną tablicę

		for (i = 0; i < local_NY; i++) {
			if (rank == 0) {
				startCol = 0;
				endCol = local_NX;
			} else if (rank == size - 1) {
				startCol = 0;
				endCol = local_NX;
			} else {
				startCol = 0;
				endCol = local_NX;
			}
			for (j = startCol; j < endCol + 1; j++) {

Dokladnie w tym momencie, kiedy nastepuja obliczenia chcialbym skopiowac lokalne tablice na GPU (za pomoca CUDY) i wykonać je na kernelach. Pytanie czy da się zrobić to w ten sposób i jeżeli tak to bardzo prosiłbym o podpowiedzi. W cudzie najlepiej wysyla się tablice w 1D, generalnie potrafię kopiować dane z CPU na GPU, ale w tej funkcji mam z tym problem.

Tak wyglada moj zamysl:

				T_last[0] = new float [local_NY * local_NX];
								
				Allocate_Memory(&T_last[0], &d_a, &d_b, local_NY, local_NX);

				Copy_All_To_GPU(&T_last[0], &d_a, &d_b, local_NY, local_NX);

				GPU_Compute(&T_last[0], &d_a, &d_b, local_NY, local_NX); 

				Copy_All_From_GPU(&T_last[0], &d_a, &d_b, local_NY, local_NX);

				}
			}
		}
	}

dalej wyswietlanie, finalizacja...

0
float **T_last = new float * [local_NY];    // T - 1
float **T = new float * [local_NY];         // T

//...

T_last= (float**) malloc(sizeof(float*) * local_NY);
    for (i = 0; i < local_NY; i++) {
        T_last[i] = (float*) malloc(sizeof(float) * (local_NX + 2));
    }
T = .... (jest robiona na tej samej zasadzie)

To wygląda jak piękny wyciek pamięci (gubionej z new) i mieszania new z malloc. Dlaczego nie użyjesz po prostu wektora i rzutować widoku 2d na 1-wymiarową tablicę? (np. tak).

1 użytkowników online, w tym zalogowanych: 0, gości: 1