MPI_Scatter and MPI_Allgather - c++

Question

Okay, so here is another question related to my previous post MPI_Broadcast using vectors
I want to scatter a matrix (4x4) in such a way that each process receives one row (total of 4 processes). I am using vectors which need to be resized and a bit of playing around. It worked well when using arrays but with vectors I can't get the desired output.
updated code (Minimal)
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <cmath>
#include <chrono>
#include <cmath>
#include <iomanip>
#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#include"mpi.h"
using namespace std;
const int num_rows1 = 4, num_rows2 = 4, num_cols1 = 4, num_cols2 = 4;
const int root = 0;
int i, j, k;
vector<vector<int> > matrix1(num_rows1, vector <int>(num_cols1));
vector<vector<int> > matrix2(num_rows2, vector <int>(num_cols2));
vector<vector<int> > result(num_rows1, vector <int>(num_cols1));
int finale[num_rows1][num_cols2];
vector<vector<int> > transpose_mat(num_cols2, vector <int>(num_rows2));
vector<int> column1(num_rows1);
vector<int> column2(num_cols2);
double start_time, end_time;
int * column3 = new int[];
//Function working with the multiplication
vector<int> mult(vector<vector<int> > A, vector<int> B)
{
//Multiplication
for (int i = 0; i < num_rows1; ++i)
{
int sum = 0;
for (int j = 0; j < num_cols1; ++j)
{
sum += A[i][j] * B[j];
}
column1.push_back(sum);
}
return column1;
}
//Function generating random matrices
vector<vector<int>> generate_matrix(int nrow, int ncol)
{
vector<vector<int>> matrix(nrow, vector <int>(ncol));
for (int i = 0; i < nrow; ++i)
{
for (int j = 0; j < ncol; ++j)
{
matrix[i][j] = (15 *rand() / RAND_MAX - 3);
}
}
return matrix;
}
//function taking the transpose
vector<vector<int>>transpose(vector<vector<int> > matrix , int nrow, int ncol)
{
//Transpose of matrix 2
for (i = 0; i < nrow; ++i)
for (j = 0; j < ncol; ++j)
{
transpose_mat[j][i] = matrix2[i][j];
}
cout << "Transpose " << endl;
for (int i = 0; i < num_rows2; ++i)
{
for (int j = 0; j < num_cols2; ++j)
{
cout << transpose_mat[i][j] << " ";
}
cout << endl;
}
return transpose_mat;
}
//main function
int main(int argc, char *argv[])
{
MPI_Status status;
MPI_Request request;
int tag = 1;
int rank;
int world_size; //Number of processes
// Initialize the MPI environment
MPI_Init(NULL, NULL);
// Get the rank of the process
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
// Get the name of the processor
char processor_name[MPI_MAX_PROCESSOR_NAME];
int name_len;
MPI_Get_processor_name(processor_name, &name_len);
// Get the number of processes
MPI_Comm_size(MPI_COMM_WORLD, &world_size);
if (rank == root)
{
//Filling
matrix1 = generate_matrix(num_rows1, num_cols1);
for (int i = 0; i < num_rows1; ++i)
{
MPI_Bcast(&matrix1[i][0], num_rows1, MPI_INT, root, MPI_COMM_WORLD);
}
}
else if (rank == 1)
{
srand(time(NULL));
//Filling
matrix2 = generate_matrix(num_rows2, num_cols2);
transpose_mat = transpose(matrix2, num_rows2, num_cols2);
}
if (rank > root)
{
int size = matrix1.size();
result.resize(size);
for (int i = 0; i < size; i++){
result[i].resize(size);
}
for (int i = 0; i < size; ++i)
{
MPI_Bcast(&result[i][0], size, MPI_INT, root, MPI_COMM_WORLD);
}
}
int size1 = transpose_mat.size();
column2.resize(size1);
//Scattering the transposed matrix
for (j = 0; j < num_rows2; ++j)
{
MPI_Scatter(&transpose_mat[0][j], size1*size1 / world_size, MPI_INT, &column2[j], size1*size1 / world_size, MPI_INT, 1, MPI_COMM_WORLD);
}
cout << "The scattered data at process " << rank << " is: " << endl;
for (int j = 0; j < num_cols2; ++j)
{
cout << column2[j] << endl;
}
MPI_Barrier(MPI_COMM_WORLD);
MPI_Finalize();
return 0;
}
In the updated PNG one can see that the first two rows of the matrix are scattered. The first one being received by Process 0 and the second row by Process 2. Why do Process 1 and Process 3 don't give the desired reault.
Updated PNG