OpenMP2 task solution is added

CompMath1/src/main.cpp

@@ -12,32 +12,84 @@ double acceleration(double t)
 
 void calc(double* trace, uint32_t traceSize, double t0, double dt, double y0, double y1, int rank, int size)
 {
-  // Sighting shot
-  double v0 = 0;
-  if (rank == 0 && size > 0)
-  {
-    trace[0] = y0;
-    trace[1] = y0 + dt*v0;
-    for (uint32_t i = 2; i < traceSize; i++)
-    {
-      trace[i] = dt*dt*acceleration(t0 + (i - 1)*dt) + 2*trace[i - 1] - trace[i - 2];
-    }
-  }
+	MPI_Status status;
+	MPI_Bcast (&traceSize, 1, MPI_INT, 0, MPI_COMM_WORLD);
+	MPI_Bcast (&t0, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+	MPI_Bcast (&dt, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
 
-  // The final shot
-  if (rank == 0 && size > 0)
-  {
-    v0 = (y1 - trace[traceSize - 1])/(dt*traceSize);
-    trace[0] = y0;
-    trace[1] = y0 + dt*v0;
-    for (uint32_t i = 2; i < traceSize; i++)
-    {
-      trace[i] = dt*dt*acceleration(t0 + (i - 1)*dt) + 2*trace[i - 1] - trace[i - 2];
-    }
-  }
+	uint32_t mySize = traceSize / size;
+	if (rank == 0) {
+		mySize += traceSize % size;
+	}
 
+	double tau = dt * mySize;
+
+	if (rank != 0) {
+		trace = (double *)malloc(mySize * sizeof(double));
+	}
+	// Sighting shot
+	double v0 = 0, v1, myY1;
+	t0 += tau * rank;
+	if (rank != 0) {
+		t0 += dt * (traceSize % size);
+	}
+	trace[0] = y0;
+	trace[1] = y0 + dt*v0;
+	for (uint32_t i = 2; i < mySize; i++) {
+		trace[i] = dt*dt*acceleration(t0 + (i - 1)*dt) + 2*trace[i - 1] - trace[i - 2];
+	}
+
+	v1 = (trace[mySize - 1] - trace[mySize - 2]) / dt;
+	myY1 = trace[mySize - 1];
+
+	if (size == 1) {
+		v0 = (y1 - myY1) / tau;
+	} else {
+		double bufY, bufV;
+		if (rank == 0) {
+			MPI_Send(&myY1, 1, MPI_DOUBLE, 1, 0, MPI_COMM_WORLD);
+			MPI_Send(&v1, 1, MPI_DOUBLE, 1, 0, MPI_COMM_WORLD);
+			MPI_Recv(&bufY, 1, MPI_DOUBLE, size - 1, 0, MPI_COMM_WORLD, &status);	
+			v0 = (y1 - bufY) / (traceSize * dt);
+			MPI_Bcast(&v0, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+		} else {
+			MPI_Recv(&bufY, 1, MPI_DOUBLE, rank - 1, 0, MPI_COMM_WORLD, &status);
+			MPI_Recv(&bufV, 1, MPI_DOUBLE, rank - 1, 0, MPI_COMM_WORLD, &status);
+
+			myY1 += bufY + bufV * (mySize - 1) * dt;
+			v1 += bufV;
+
+			if (rank != size - 1) {
+				MPI_Send(&myY1, 1, MPI_DOUBLE, rank + 1, 0, MPI_COMM_WORLD);
+				MPI_Send(&v1, 1, MPI_DOUBLE, rank + 1, 0, MPI_COMM_WORLD);	
+			} else {
+				MPI_Send(&myY1, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
+			}
+
+			MPI_Bcast(&v0, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+			y0 = bufY + v0 * tau * rank + v0 * dt * (traceSize % size);
+			v0 += bufV;
+		}
+
+}		
+  // The final shot
+	trace[0] = y0;
+	trace[1] = y0 + dt*v0;
+	for (uint32_t i = 2; i < mySize; i++) {
+		 trace[i] = dt*dt*acceleration(t0 + (i - 1)*dt) + 2*trace[i - 1] - trace[i - 2];
+	}
+	if (rank == 0) {
+		mySize -= (traceSize % size);
+		for(int i = 1; i < size; i++) {
+			MPI_Recv(&trace[i * mySize + (traceSize % size)], mySize, MPI_DOUBLE, i, 0, MPI_COMM_WORLD, &status);
+		}
+	} else {
+		MPI_Send(trace, mySize, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
+		free(trace);
+	}
 }
 
+
 int main(int argc, char** argv)
 {
   int rank = 0, size = 0, status = 0;

CompMath2/src/main.cpp

@@ -7,64 +7,112 @@
 
 void calc(double* frame, uint32_t ySize, uint32_t xSize, double delta, int rank, int size)
 {
-  if (rank == 0 && size > 0)
-  {
-    double diff = 0;
-    double* tmpFrame = new double[ySize * xSize];
-    // Prepare tmpFrame
-    for (uint32_t y = 0; y < ySize; y++)
-    {
-      tmpFrame[y*xSize] = frame[y*xSize];
-      tmpFrame[y*xSize + xSize - 1] = frame[y*xSize + xSize - 1];
-    }
-    for (uint32_t x = 1; x < xSize - 1; x++)
-    {
-      tmpFrame[x] = frame[x];
-      tmpFrame[(ySize - 1)*xSize + x] = frame[(ySize - 1)*xSize + x];
-    }
-    // Calculate first iteration
-    for (uint32_t y = 1; y < ySize - 1; y++)
-    {
-      for (uint32_t x = 1; x < xSize - 1; x++)
-      {
-        tmpFrame[y*xSize + x] = (frame[(y + 1)*xSize + x] + frame[(y - 1)*xSize + x] +\
-                                frame[y*xSize + x + 1] + frame[y*xSize + x - 1])/4.0;
-        diff += std::abs(tmpFrame[y*xSize + x] - frame[y*xSize + x]);
-      }
-    }
+	MPI_Status status;
+	MPI_Bcast (&xSize, 1, MPI_INT, 0, MPI_COMM_WORLD);
+	MPI_Bcast (&ySize, 1, MPI_INT, 0, MPI_COMM_WORLD);
+	MPI_Bcast (&delta, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
 
-    double* currFrame = tmpFrame;
-    double* nextFrame = frame;
-    uint32_t iteration = 1;
-    // Calculate frames
-    while (diff > delta)
-    {
-      diff = 0;
-      for (uint32_t y = 1; y < ySize - 1; y++)
-      {
-        for (uint32_t x = 1; x < xSize - 1; x++)
-        {
-          nextFrame[y*xSize + x] = (currFrame[(y + 1)*xSize + x] + currFrame[(y - 1)*xSize + x] +\
-                                  currFrame[y*xSize + x + 1] + currFrame[y*xSize + x - 1])/4.0;
-          diff += std::abs(nextFrame[y*xSize + x] - currFrame[y*xSize + x]);
-        }
-      }
-      std::swap(currFrame, nextFrame);
-      iteration++;
-    }
 
-    // Copy result from tmp
-    if (iteration % 2 == 1)
-    {
-      for (uint32_t i = 0; i < xSize*ySize; i++)
-      {
-        frame[i] = tmpFrame[i];
-      }
-    }
-    delete tmpFrame;
-  }
+	uint32_t mySize = ySize / size;
+	uint32_t yFirst = mySize * rank + ySize % size;
+
+	if (rank == 0) {
+		yFirst = 1;
+		mySize += ySize % size - 1;
+	}
+
+	if (rank == size - 1) {
+		mySize--;
+	}
+
+	uint32_t yLast = yFirst + mySize;
+
+	double diff = 0;
+
+	if (mySize == 0) {
+		diff = 2 * delta;
+	}
+
+	double* inFrame = (double *)malloc(xSize * ySize * sizeof(double));
+
+	if (rank > 0) {
+		frame = (double *)malloc(xSize * ySize * sizeof(double));
+	}
+
+	MPI_Bcast (frame, xSize * ySize, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+	memcpy(inFrame, frame, xSize * ySize * sizeof (double));
+
+	for (uint32_t y = yFirst; y < yLast; y++) {
+		for (uint32_t x = 1; x < xSize - 1; x++) {
+			inFrame[y * xSize + (x)] = (frame[(y + 1) * xSize + x] + frame[(y - 1) * xSize + x] + frame[y * xSize + x + 1] + frame[y * xSize + x - 1]) / 4.0;
+			diff += std::abs(inFrame[y * xSize + x] - frame[y * xSize + x]);
+		}
+	}
+
+	double* p;
+
+	while (diff > delta)
+	{
+		p = inFrame;
+		inFrame = frame;
+		frame = p;
+
+		diff = 0;
+
+		if (size > 1) {
+			if (rank == 0) {
+				MPI_Send (inFrame + (yLast - 1) * xSize, xSize, MPI_DOUBLE, rank + 1, 0, MPI_COMM_WORLD);
+			} else {
+				MPI_Recv (inFrame + (yFirst - 1) * xSize, xSize, MPI_DOUBLE, rank - 1, 0, MPI_COMM_WORLD, &status);
+				if (rank != size - 1) {
+					MPI_Send (inFrame + (yLast - 1) * xSize, xSize, MPI_DOUBLE, rank + 1, 0, MPI_COMM_WORLD);
+				}
+			}
+			if (rank == size - 1) {
+				MPI_Send (inFrame + yFirst * xSize, xSize, MPI_DOUBLE, rank - 1, 0, MPI_COMM_WORLD);
+			} else {
+				MPI_Recv (inFrame + yLast * xSize, xSize, MPI_DOUBLE, rank + 1, 0, MPI_COMM_WORLD, &status);
+				if (rank != 0) {
+					MPI_Send (inFrame + yFirst * xSize, xSize, MPI_DOUBLE, rank - 1, 0, MPI_COMM_WORLD);
+				}
+			}
+		}
+
+
+
+		for (uint32_t y = yFirst; y < yLast; y++) {
+			for (uint32_t x = 1; x < xSize - 1; x++) {
+				frame[y * xSize + x] = (inFrame[(y + 1) * xSize + x] + inFrame[(y - 1) * xSize + x] + inFrame[y * xSize + x + 1] + inFrame[y * xSize + x - 1]) / 4.0;
+				diff += std::abs(frame[y * xSize + x] - inFrame[y * xSize + x]);
+			}
+		}
+
+		MPI_Allreduce(&diff, &diff, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
+
+	}
+
+	if (rank == 0) {
+		yFirst += mySize;
+		mySize -= (ySize % size - 1);
+		for (int i = 1; i < size; i++) {
+			if (i == size - 1) {
+				mySize--;
+			}
+			MPI_Recv (frame + yFirst * xSize, mySize * xSize, MPI_DOUBLE, i, 0, MPI_COMM_WORLD, &status);
+			yFirst += mySize;
+		}
+	} else {
+		MPI_Send (frame + yFirst * xSize, mySize * xSize, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
+	}
+
+	free (inFrame);
+
+	if (rank > 0) {
+		free (frame);
+	}
 }
 
+
 int main(int argc, char** argv)
 {
   int rank = 0, size = 0, status = 0;

Loop1/src/main.cpp

@@ -5,18 +5,49 @@
 #include <unistd.h>
 #include <cmath>
 
+void sum(double* res, uint32_t xSize, uint32_t ySize) {
+	for (uint32_t y = 0; y < ySize; y++) {
+	  for (uint32_t x = 0; x < xSize; x++) {
+	    res[y*xSize + x] = sin(0.00001*res[y*xSize + x]);
+	  }
+	}
+}
+
+
 void calc(double* arr, uint32_t ySize, uint32_t xSize, int rank, int size)
 {
-  if (rank == 0 && size > 0)
-  {
-    for (uint32_t y = 0; y < ySize; y++)
-    {
-      for (uint32_t x = 0; x < xSize; x++)
-      {
-        arr[y*xSize + x] = sin(0.00001*arr[y*xSize + x]);
-      }
-    }
-  }
+	MPI_Bcast(&ySize, 1, MPI_INT, 0, MPI_COMM_WORLD);	
+	MPI_Bcast(&xSize, 1, MPI_INT, 0, MPI_COMM_WORLD);	
+	uint32_t loc_ySize = ySize / size;
+	if (rank < (int)ySize % size) {
+		loc_ySize++;
+	}
+	double* res = (double*)malloc(loc_ySize * xSize * sizeof(double));
+
+	if (rank == 0) {
+		int* displs = (int*)malloc(size * sizeof(int));
+		int* sendcounts = (int*)malloc(size * sizeof(int));
+		int offset = 0;
+		for (int i = 0; i < size; i++) {
+			displs[i] = offset;
+			sendcounts[i] = ySize / size;
+			if (i < (int)ySize % size) {
+				sendcounts[i]++;
+			}
+			sendcounts[i] *= xSize;
+			offset += sendcounts[i];
+		}
+		MPI_Scatterv(arr, sendcounts, displs, MPI_DOUBLE, res, loc_ySize * xSize, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+		sum(res, xSize, loc_ySize);
+		MPI_Gatherv(res, loc_ySize * xSize, MPI_DOUBLE, arr, sendcounts, displs, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+		free(displs);
+		free(sendcounts);
+	} else {
+		MPI_Scatterv(NULL, NULL, NULL, 0, res, loc_ySize * xSize, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+		sum(res, xSize, loc_ySize);
+		MPI_Gatherv(res, loc_ySize * xSize, MPI_DOUBLE, NULL, NULL, NULL, 0, 0, MPI_COMM_WORLD);
+	}
+	free(res);
 }
 
 int main(int argc, char** argv)