Studium_Angewandte_Informatik_Bachelor/hpc_laboratory_exercises
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

stocher

Browse Source
This commit is contained in:
WickedJack99
2025-06-16 21:20:13 +02:00
parent 15791914e9
commit ed7896349f
4 changed files with 184 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
lab11/game_of_life/game_of_life.cpp
View File

@@ -7,7 +7,7 @@ void GameOfLife::step() {
SuperGrid next = SuperGrid::zeros(grid_.rows(), grid_.cols(), grid_.get_communicator());
const int rows = grid_.rows();
const int cols = grid_.cols();
grid_.update();
//grid_.update();
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
const int numLiveNeighbors = countLiveNeighbors(i, j);

74
lab11/game_of_life/super_grid.cpp
View File

@@ -4,11 +4,11 @@
std::vector<MPI_Request> SuperGrid::receive_halos(HaloLayers halo_layers)
{
std::vector<MPI_Request> recv_requests(8);
std::cout << halo_layers.top_row.size() << std::endl;
MPI_Irecv(halo_layers.top_row.data(), halo_layers.top_row.size(), MPI_DOUBLE, neighbors_.top, neighbors_.top, comm_, &recv_requests[0]);
MPI_Irecv(halo_layers.right_row.data(), halo_layers.right_row.size(), MPI_DOUBLE, neighbors_.right, neighbors_.right, comm_, &recv_requests[1]);
MPI_Irecv(halo_layers.bottom_row.data(), halo_layers.bottom_row.size(), MPI_DOUBLE, neighbors_.bottom, neighbors_.bottom, comm_, &recv_requests[2]);
MPI_Irecv(halo_layers.left_row.data(), halo_layers.left_row.size(), MPI_DOUBLE, neighbors_.left, neighbors_.left, comm_, &recv_requests[3]);
std::cout << halo_layers.top_halo.size() << std::endl;
MPI_Irecv(halo_layers.top_halo.data(), halo_layers.top_halo.size(), MPI_DOUBLE, neighbors_.top, neighbors_.top, comm_, &recv_requests[0]);
MPI_Irecv(halo_layers.right_halo.data(), halo_layers.right_halo.size(), MPI_DOUBLE, neighbors_.right, neighbors_.right, comm_, &recv_requests[1]);
MPI_Irecv(halo_layers.bottom_halo.data(), halo_layers.bottom_halo.size(), MPI_DOUBLE, neighbors_.bottom, neighbors_.bottom, comm_, &recv_requests[2]);
MPI_Irecv(halo_layers.left_halo.data(), halo_layers.left_halo.size(), MPI_DOUBLE, neighbors_.left, neighbors_.left, comm_, &recv_requests[3]);
MPI_Irecv(&halo_layers.top_right_corner, 1, MPI_DOUBLE, neighbors_.top_right, neighbors_.top_right, comm_, &recv_requests[4]);
MPI_Irecv(&halo_layers.bottom_right_corner, 1, MPI_DOUBLE, neighbors_.bottom_right, neighbors_.bottom_right, comm_, &recv_requests[5]);
@@ -18,7 +18,7 @@ std::vector<MPI_Request> SuperGrid::receive_halos(HaloLayers halo_layers)
return recv_requests;
}
std::vector<double> SuperGrid::get_top_row()
std::vector<double> SuperGrid::get_inner_top_row()
{
std::vector<double> row(cols());
for (int j = 0; j < cols(); ++j)
@@ -26,7 +26,7 @@ std::vector<double> SuperGrid::get_top_row()
return row;
}
std::vector<double> SuperGrid::get_bottom_row()
std::vector<double> SuperGrid::get_inner_bottom_row()
{
std::vector<double> row(cols());
for (int j = 0; j < cols(); ++j)
@@ -34,7 +34,7 @@ std::vector<double> SuperGrid::get_bottom_row()
return row;
}
std::vector<double> SuperGrid::get_left_row()
std::vector<double> SuperGrid::get_inner_left_column()
{
std::vector<double> col(rows());
for (int i = 0; i < rows(); ++i)
@@ -42,7 +42,7 @@ std::vector<double> SuperGrid::get_left_row()
return col;
}
std::vector<double> SuperGrid::get_right_row()
std::vector<double> SuperGrid::get_inner_right_column()
{
std::vector<double> col(rows());
for (int i = 0; i < rows(); ++i)
@@ -50,37 +50,37 @@ std::vector<double> SuperGrid::get_right_row()
return col;
}
double SuperGrid::get_top_left_corner()
double SuperGrid::get_inner_top_left_corner()
{
return (*this)(0, 0);
}
double SuperGrid::get_top_right_corner()
double SuperGrid::get_inner_top_right_corner()
{
return (*this)(cols() - 1, 0);
}
double SuperGrid::get_bottom_left_corner()
double SuperGrid::get_inner_bottom_left_corner()
{
return (*this)(0, rows() - 1);
}
double SuperGrid::get_bottom_right_corner()
double SuperGrid::get_inner_bottom_right_corner()
{
return (*this)(cols() - 1, rows() - 1);
}
std::vector<MPI_Request> SuperGrid::inform_neighbors()
{
std::vector<double> top_row = get_top_row();
std::vector<double> right_row = get_right_row();
std::vector<double> bottom_row = get_bottom_row();
std::vector<double> left_row = get_left_row();
std::vector<double> inner_top_row = get_inner_top_row();
std::vector<double> inner_right_column = get_inner_right_column();
std::vector<double> inner_bottom_row = get_inner_bottom_row();
std::vector<double> inner_left_column = get_inner_left_column();
double top_right_corner = get_top_right_corner();
double bottom_right_corner = get_bottom_right_corner();
double top_left_corner = get_top_left_corner();
double bottom_left_corner = get_bottom_left_corner();
double inner_top_right_corner = get_inner_top_right_corner();
double inner_bottom_right_corner = get_inner_bottom_right_corner();
double inner_top_left_corner = get_inner_top_left_corner();
double inner_bottom_left_corner = get_inner_bottom_left_corner();
if (rank_ == 0)
{
@@ -96,16 +96,16 @@ std::vector<MPI_Request> SuperGrid::inform_neighbors()
}
std::vector<MPI_Request> send_requests(8);
std::cout << top_row.size() << "inform_neighbors" << std::endl;
MPI_Isend(top_row.data(), top_row.size(), MPI_DOUBLE, neighbors_.top, rank_, comm_, &send_requests[0]);
MPI_Isend(right_row.data(), right_row.size(), MPI_DOUBLE, neighbors_.right, rank_, comm_, &send_requests[1]);
MPI_Isend(bottom_row.data(), bottom_row.size(), MPI_DOUBLE, neighbors_.bottom, rank_, comm_, &send_requests[2]);
MPI_Isend(left_row.data(), left_row.size(), MPI_DOUBLE, neighbors_.left, rank_, comm_, &send_requests[3]);
std::cout << inner_top_row.size() << "inform_neighbors" << std::endl;
MPI_Isend(inner_top_row.data(), inner_top_row.size(), MPI_DOUBLE, neighbors_.top, rank_, comm_, &send_requests[0]);
MPI_Isend(inner_right_column.data(), inner_right_column.size(), MPI_DOUBLE, neighbors_.right, rank_, comm_, &send_requests[1]);
MPI_Isend(inner_bottom_row.data(), inner_bottom_row.size(), MPI_DOUBLE, neighbors_.bottom, rank_, comm_, &send_requests[2]);
MPI_Isend(inner_left_column.data(), inner_left_column.size(), MPI_DOUBLE, neighbors_.left, rank_, comm_, &send_requests[3]);
MPI_Isend(&top_right_corner, 1, MPI_DOUBLE, neighbors_.top_right, rank_, comm_, &send_requests[4]);
MPI_Isend(&bottom_right_corner, 1, MPI_DOUBLE, neighbors_.bottom_right, rank_, comm_, &send_requests[5]);
MPI_Isend(&top_left_corner, 1, MPI_DOUBLE, neighbors_.top_left, rank_, comm_, &send_requests[6]);
MPI_Isend(&bottom_left_corner, 1, MPI_DOUBLE, neighbors_.bottom_left, rank_, comm_, &send_requests[7]);
MPI_Isend(&inner_top_right_corner, 1, MPI_DOUBLE, neighbors_.top_right, rank_, comm_, &send_requests[4]);
MPI_Isend(&inner_bottom_right_corner, 1, MPI_DOUBLE, neighbors_.bottom_right, rank_, comm_, &send_requests[5]);
MPI_Isend(&inner_top_left_corner, 1, MPI_DOUBLE, neighbors_.top_left, rank_, comm_, &send_requests[6]);
MPI_Isend(&inner_bottom_left_corner, 1, MPI_DOUBLE, neighbors_.bottom_left, rank_, comm_, &send_requests[7]);
return send_requests;
}
@@ -128,28 +128,28 @@ void SuperGrid::update()
void SuperGrid::merge_halos(HaloLayers halo_layers)
{
grid_(0, 0) = halo_layers.top_left_corner;
grid_(grid_.cols(), 0) = halo_layers.top_right_corner;
grid_(0, grid_.rows()) = halo_layers.bottom_left_corner;
grid_(grid_.cols(), grid_.rows()) = halo_layers.bottom_right_corner;
grid_(grid_.cols() - 1, 0) = halo_layers.top_right_corner;
grid_(0, grid_.rows() - 1) = halo_layers.bottom_left_corner;
grid_(grid_.cols() - 1, grid_.rows() - 1) = halo_layers.bottom_right_corner;
for (int col = 1; col < grid_.cols() - 1; col++)
{
grid_(col, 0) = halo_layers.top_row[col - 1];
grid_(col, 0) = halo_layers.top_halo[col - 1];
}
for (int col = 1; col < grid_.cols() - 1; col++)
{
grid_(col, grid_.rows() - 1) = halo_layers.bottom_row[col - 1];
grid_(col, grid_.rows() - 1) = halo_layers.bottom_halo[col - 1];
}
for (int row = 1; row < grid_.rows() - 1; row++)
{
grid_(0, row) = halo_layers.left_row[row - 1];
grid_(0, row) = halo_layers.left_halo[row - 1];
}
for (int row = 1; row < grid_.rows() - 1; row++)
{
grid_(grid_.cols() - 1, row) = halo_layers.right_row[row - 1];
grid_(grid_.cols() - 1, row) = halo_layers.right_halo[row - 1];
}
}

40
lab11/game_of_life/super_grid.h
View File

@@ -8,10 +8,10 @@
class HaloLayers
{
public:
std::vector<double> top_row;
std::vector<double> right_row;
std::vector<double> bottom_row;
std::vector<double> left_row;
std::vector<double> top_halo;
std::vector<double> right_halo;
std::vector<double> bottom_halo;
std::vector<double> left_halo;
double top_right_corner;
double bottom_right_corner;
@@ -19,10 +19,10 @@ public:
double bottom_left_corner;
HaloLayers(int row_size = 0, int col_size = 0)
: top_row(col_size),
right_row(row_size),
bottom_row(col_size),
left_row(row_size),
: top_halo(col_size),
right_halo(row_size),
bottom_halo(col_size),
left_halo(row_size),
top_right_corner(0.0),
bottom_right_corner(0.0),
top_left_corner(0.0),
@@ -82,23 +82,23 @@ public:
std::vector<MPI_Request> receive_halos(HaloLayers halo_layers);
std::vector<MPI_Request> inform_neighbors();
std::vector<double> get_inner_top_row();
std::vector<double> get_inner_right_column();
std::vector<double> get_inner_bottom_row();
std::vector<double> get_inner_left_column();
double get_inner_top_right_corner();
double get_inner_bottom_right_corner();
double get_inner_top_left_corner();
double get_inner_bottom_left_corner();
void merge_halos(HaloLayers halo_layers);
private:
Matrix grid_;
MPI_Comm comm_;
Neighbors neighbors_;
int rank_;
std::vector<double> get_top_row();
std::vector<double> get_right_row();
std::vector<double> get_bottom_row();
std::vector<double> get_left_row();
double get_top_right_corner();
double get_bottom_right_corner();
double get_top_left_corner();
double get_bottom_left_corner();
void merge_halos(HaloLayers halo_layers);
};
inline SuperGrid::SuperGrid(const Matrix &other)

128
lab11/game_of_life/test.cpp
View File

@@ -13,6 +13,20 @@ Matrix init_step(SuperGrid start)
return gol.getGrid();
}
SuperGrid init(int dim)
{
MPI_Comm comm_;
int num_procs = 16;
MPIGridSize mpiProcs = {4, 4};
MPI_Dims_create(num_procs, 2, mpiProcs.data());
std::array<int, 2> periods = {1, 1};
MPI_Cart_create(MPI_COMM_WORLD, 2, mpiProcs.data(), periods.data(), true,
&comm_);
return SuperGrid::zeros(dim, dim, comm_);
}
SuperGrid init()
{
MPI_Comm comm_;
@@ -123,7 +137,6 @@ TEST(test_find_neighbors)
expected.bottom_right = 5;
check(neighbors == expected, true);
}
MPI_Finalize();
}
TEST(communication)
@@ -145,8 +158,119 @@ TEST(communication)
}
}
TEST(get_halo_layers)
TEST(get_inner_top_row)
{
SuperGrid su_grid = init(5);
su_grid(0, 0) = 1;
su_grid(1, 0) = 2;
su_grid(2, 0) = 3;
su_grid(3, 0) = 4;
su_grid(4, 0) = 5;
std::vector<double> expected = {1,2,3,4,5};
check(su_grid.get_inner_top_row() == expected, true);
}
TEST(get_inner_bottom_row)
{
SuperGrid su_grid = init(5);
su_grid(0, 4) = 1;
su_grid(1, 4) = 2;
su_grid(2, 4) = 3;
su_grid(3, 4) = 4;
su_grid(4, 4) = 5;
std::vector<double> expected = {1,2,3,4,5};
check(su_grid.get_inner_bottom_row() == expected, true);
}
TEST(get_inner_left_column)
{
SuperGrid su_grid = init(5);
su_grid(0, 0) = 1;
su_grid(0, 1) = 2;
su_grid(0, 2) = 3;
su_grid(0, 3) = 4;
su_grid(0, 4) = 5;
std::vector<double> expected = {1,2,3,4,5};
check(su_grid.get_inner_left_column() == expected, true);
}
TEST(get_inner_right_column)
{
SuperGrid su_grid = init(5);
su_grid(4, 0) = 1;
su_grid(4, 1) = 2;
su_grid(4, 2) = 3;
su_grid(4, 3) = 4;
su_grid(4, 4) = 5;
std::vector<double> expected = {1,2,3,4,5};
check(su_grid.get_inner_right_column() == expected, true);
}
TEST(get_inner_top_left_corner)
{
SuperGrid su_grid = init(5);
su_grid(0, 0) = 42.0;
check(su_grid.get_inner_top_left_corner() == 42.0, true);
}
TEST(get_inner_top_right_corner)
{
SuperGrid su_grid = init(5);
su_grid(4, 0) = 17.0;
check(su_grid.get_inner_top_right_corner() == 17.0, true);
}
TEST(get_inner_bottom_left_corner)
{
SuperGrid su_grid = init(5);
su_grid(0, 4) = 3.14;
check(su_grid.get_inner_bottom_left_corner() == 3.14, true);
}
TEST(get_inner_bottom_right_corner)
{
SuperGrid su_grid = init(5);
su_grid(4, 4) = -1.5;
check(su_grid.get_inner_bottom_right_corner() == -1.5, true);
}
TEST(merge_halos)
{
SuperGrid su_grid = init(5);
HaloLayers halo_layers;
halo_layers.top_halo = {1, 2, 3, 4, 1};
halo_layers.bottom_halo = {1, 2, 3, 4, 1};
halo_layers.left_halo = {1, 2, 3, 4, 1};
halo_layers.right_halo = {1, 2, 3, 4, 1};
halo_layers.top_left_corner = 0;
halo_layers.top_right_corner = 0;
halo_layers.bottom_left_corner = 0;
halo_layers.bottom_right_corner = 0;
su_grid.merge_halos(halo_layers);
int rank;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
if (rank == 0) {
print(su_grid.get_grid());
}
}
TEST(finalize)
{
MPI_Finalize();
check(true, true);
}
int main(int argc, char *argv[]) {