diff --git a/.hadolint.yaml b/.hadolint.yaml index b91b263f..e5cb49a3 100644 --- a/.hadolint.yaml +++ b/.hadolint.yaml @@ -1,3 +1,3 @@ ignored: - - DL3008 # Pin versions in apt-get install - - DL3018 # Pin versions in apk add + - DL3008 # Pin versions in apt-get install + - DL3018 # Pin versions in apk add diff --git a/Testing/Temporary/CTestCostData.txt b/Testing/Temporary/CTestCostData.txt new file mode 100644 index 00000000..ed97d539 --- /dev/null +++ b/Testing/Temporary/CTestCostData.txt @@ -0,0 +1 @@ +--- diff --git a/Testing/Temporary/LastTest.log b/Testing/Temporary/LastTest.log new file mode 100644 index 00000000..cad0f40e --- /dev/null +++ b/Testing/Temporary/LastTest.log @@ -0,0 +1,3 @@ +Start testing: Mar 01 13:35 UTC +---------------------------------------------------------- +End testing: Mar 01 13:35 UTC diff --git a/data/klimov_m_shell_odd_even_merge/test1.txt b/data/klimov_m_shell_odd_even_merge/test1.txt new file mode 100644 index 00000000..e69de29b diff --git a/data/klimov_m_shell_odd_even_merge/test2.txt b/data/klimov_m_shell_odd_even_merge/test2.txt new file mode 100644 index 00000000..e69de29b diff --git a/data/klimov_m_shell_odd_even_merge/test3.txt b/data/klimov_m_shell_odd_even_merge/test3.txt new file mode 100644 index 00000000..e69de29b diff --git a/tasks/dergynov_s_hypercube/info.json b/tasks/dergynov_s_hypercube/info.json index b3aebbf2..96fbab87 100644 --- a/tasks/dergynov_s_hypercube/info.json +++ b/tasks/dergynov_s_hypercube/info.json @@ -1,9 +1,9 @@ { "student": { - "first_name": "\u0421\u0435\u0440\u0433\u0435\u0439", - "group_number": "3823\u04111\u041f\u04204", - "last_name": "\u0414\u0435\u0440\u0433\u0443\u043d\u043e\u0432", - "middle_name": "\u0410\u043d\u0442\u043e\u043d\u043e\u0432\u0438\u0447", + "first_name": "Сергей", + "group_number": "3823Б1ПР4", + "last_name": "Дергунов", + "middle_name": "Антонович", "task_number": "2" } } diff --git a/tasks/dergynov_s_radix_sort_double_simple_merge/info.json b/tasks/dergynov_s_radix_sort_double_simple_merge/info.json index c4c78494..5dfba0a4 100644 --- a/tasks/dergynov_s_radix_sort_double_simple_merge/info.json +++ b/tasks/dergynov_s_radix_sort_double_simple_merge/info.json @@ -1,9 +1,9 @@ { "student": { - "first_name": "\u0421\u0435\u0440\u0433\u0435\u0439", - "group_number": "3823\u04111\u041f\u04204", - "last_name": "\u0414\u0435\u0440\u0433\u0443\u043d\u043e\u0432", - "middle_name": "\u0410\u043d\u0442\u043e\u043d\u043e\u0432\u0438\u0447", + "first_name": "Сергей", + "group_number": "3823Б1ПР4", + "last_name": "Дергунов", + "middle_name": "Антонович", "task_number": "3" } } diff --git a/tasks/dergynov_s_trapezoid_integration/info.json b/tasks/dergynov_s_trapezoid_integration/info.json index c5a8145b..5cb7fa89 100644 --- a/tasks/dergynov_s_trapezoid_integration/info.json +++ b/tasks/dergynov_s_trapezoid_integration/info.json @@ -1,9 +1,9 @@ { "student": { - "first_name": "\u0421\u0435\u0440\u0433\u0435\u0439", - "group_number": "3823\u04111\u041f\u04204", - "last_name": "\u0414\u0435\u0440\u0433\u0443\u043d\u043e\u0432", - "middle_name": "\u0410\u043d\u0442\u043e\u043d\u043e\u0432\u0438\u0447", + "first_name": "Сергей", + "group_number": "3823Б1ПР4", + "last_name": "Дергунов", + "middle_name": "Антонович", "task_number": "1" } } diff --git a/tasks/klimov_m_shell_odd_even_merge/common/include/common.hpp b/tasks/klimov_m_shell_odd_even_merge/common/include/common.hpp new file mode 100644 index 00000000..a75d973b --- /dev/null +++ b/tasks/klimov_m_shell_odd_even_merge/common/include/common.hpp @@ -0,0 +1,15 @@ +#pragma once + +#include +#include + +#include "task/include/task.hpp" + +namespace klimov_m_shell_odd_even_merge { + +using InputType = std::vector; +using OutputType = std::vector; +using TestParam = std::string; +using BaseTask = ppc::task::Task; + +} // namespace klimov_m_shell_odd_even_merge diff --git a/tasks/klimov_m_shell_odd_even_merge/data/test1.txt b/tasks/klimov_m_shell_odd_even_merge/data/test1.txt new file mode 100644 index 00000000..4225560b --- /dev/null +++ b/tasks/klimov_m_shell_odd_even_merge/data/test1.txt @@ -0,0 +1 @@ +17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 \ No newline at end of file diff --git a/tasks/klimov_m_shell_odd_even_merge/data/test2.txt b/tasks/klimov_m_shell_odd_even_merge/data/test2.txt new file mode 100644 index 00000000..56efbc77 --- /dev/null +++ b/tasks/klimov_m_shell_odd_even_merge/data/test2.txt @@ -0,0 +1 @@ +1000 999 998 997 996 995 994 993 992 991 990 989 988 987 986 985 984 983 982 981 980 979 978 977 976 975 974 973 972 971 970 969 968 967 966 965 964 963 962 961 960 959 958 957 956 955 954 953 952 951 950 949 948 947 946 945 944 943 942 941 940 939 938 937 936 935 934 933 932 931 930 929 928 927 926 925 924 923 922 921 920 919 918 917 916 915 914 913 912 911 910 909 908 907 906 905 904 903 902 901 900 899 898 897 896 895 894 893 892 891 890 889 888 887 886 885 884 883 882 881 880 879 878 877 876 875 874 873 872 871 870 869 868 867 866 865 864 863 862 861 860 859 858 857 856 855 854 853 852 851 850 849 848 847 846 845 844 843 842 841 840 839 838 837 836 835 834 833 832 831 830 829 828 827 826 825 824 823 822 821 820 819 818 817 816 815 814 813 812 811 810 809 808 807 806 805 804 803 802 801 800 799 798 797 796 795 794 793 792 791 790 789 788 787 786 785 784 783 782 781 780 779 778 777 776 775 774 773 772 771 770 769 768 767 766 765 764 763 762 761 760 759 758 757 756 755 754 753 752 751 750 749 748 747 746 745 744 743 742 741 740 739 738 737 736 735 734 733 732 731 730 729 728 727 726 725 724 723 722 721 720 719 718 717 716 715 714 713 712 711 710 709 708 707 706 705 704 703 702 701 700 699 698 697 696 695 694 693 692 691 690 689 688 687 686 685 684 683 682 681 680 679 678 677 676 675 674 673 672 671 670 669 668 667 666 665 664 663 662 661 660 659 658 657 656 655 654 653 652 651 650 649 648 647 646 645 644 643 642 641 640 639 638 637 636 635 634 633 632 631 630 629 628 627 626 625 624 623 622 621 620 619 618 617 616 615 614 613 612 611 610 609 608 607 606 605 604 603 602 601 600 599 598 597 596 595 594 593 592 591 590 589 588 587 586 585 584 583 582 581 580 579 578 577 576 575 574 573 572 571 570 569 568 567 566 565 564 563 562 561 560 559 558 557 556 555 554 553 552 551 550 549 548 547 546 545 544 543 542 541 540 539 538 537 536 535 534 533 532 531 530 529 528 527 526 525 524 523 522 521 520 519 518 517 516 515 514 513 512 511 510 509 508 507 506 505 504 503 502 501 500 499 498 497 496 495 494 493 492 491 490 489 488 487 486 485 484 483 482 481 480 479 478 477 476 475 474 473 472 471 470 469 468 467 466 465 464 463 462 461 460 459 458 457 456 455 454 453 452 451 450 449 448 447 446 445 444 443 442 441 440 439 438 437 436 435 434 433 432 431 430 429 428 427 426 425 424 423 422 421 420 419 418 417 416 415 414 413 412 411 410 409 408 407 406 405 404 403 402 401 400 399 398 397 396 395 394 393 392 391 390 389 388 387 386 385 384 383 382 381 380 379 378 377 376 375 374 373 372 371 370 369 368 367 366 365 364 363 362 361 360 359 358 357 356 355 354 353 352 351 350 349 348 347 346 345 344 343 342 341 340 339 338 337 336 335 334 333 332 331 330 329 328 327 326 325 324 323 322 321 320 319 318 317 316 315 314 313 312 311 310 309 308 307 306 305 304 303 302 301 300 299 298 297 296 295 294 293 292 291 290 289 288 287 286 285 284 283 282 281 280 279 278 277 276 275 274 273 272 271 270 269 268 267 266 265 264 263 262 261 260 259 258 257 256 255 254 253 252 251 250 249 248 247 246 245 244 243 242 241 240 239 238 237 236 235 234 233 232 231 230 229 228 227 226 225 224 223 222 221 220 219 218 217 216 215 214 213 212 211 210 209 208 207 206 205 204 203 202 201 200 199 198 197 196 195 194 193 192 191 190 189 188 187 186 185 184 183 182 181 180 179 178 177 176 175 174 173 172 171 170 169 168 167 166 165 164 163 162 161 160 159 158 157 156 155 154 153 152 151 150 149 148 147 146 145 144 143 142 141 140 139 138 137 136 135 134 133 132 131 130 129 128 127 126 125 124 123 122 121 120 119 118 117 116 115 114 113 112 111 110 109 108 107 106 105 104 103 102 101 100 99 98 97 96 95 94 93 92 91 90 89 88 87 86 85 84 83 82 81 80 79 78 77 76 75 74 73 72 71 70 69 68 67 66 65 64 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 \ No newline at end of file diff --git a/tasks/klimov_m_shell_odd_even_merge/data/test3.txt b/tasks/klimov_m_shell_odd_even_merge/data/test3.txt new file mode 100644 index 00000000..851912b7 --- /dev/null +++ b/tasks/klimov_m_shell_odd_even_merge/data/test3.txt @@ -0,0 +1 @@ +25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 \ No newline at end of file diff --git a/tasks/klimov_m_shell_odd_even_merge/info.json b/tasks/klimov_m_shell_odd_even_merge/info.json new file mode 100644 index 00000000..f26b5bc3 --- /dev/null +++ b/tasks/klimov_m_shell_odd_even_merge/info.json @@ -0,0 +1,9 @@ +{ + "student": { + "first_name": "Михаил", + "group_number": "3823Б1ПР2", + "last_name": "Климов", + "middle_name": "Дмитриевич", + "task_number": "3" + } +} diff --git a/tasks/klimov_m_shell_odd_even_merge/mpi/include/ops_mpi.hpp b/tasks/klimov_m_shell_odd_even_merge/mpi/include/ops_mpi.hpp new file mode 100644 index 00000000..20cc9185 --- /dev/null +++ b/tasks/klimov_m_shell_odd_even_merge/mpi/include/ops_mpi.hpp @@ -0,0 +1,33 @@ +#pragma once + +#include + +#include + +#include "klimov_m_shell_odd_even_merge/common/include/common.hpp" +#include "task/include/task.hpp" + +namespace klimov_m_shell_odd_even_merge { + +class ShellBatcherMPI : public BaseTask { + public: + static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() { + return ppc::task::TypeOfTask::kMPI; + } + explicit ShellBatcherMPI(const InputType &input); + + bool ValidationImpl() override; + bool PreProcessingImpl() override; + bool RunImpl() override; + bool PostProcessingImpl() override; +}; + +void ShellSortLocal(std::vector &data); +std::vector MergeEvenLeft(std::vector &left, std::vector &right, int chunk, int rank, MPI_Comm comm); +std::vector MergeOddRight(std::vector &left, std::vector &right, int chunk, int rank, MPI_Comm comm); +void ExchangeWithRight(int rank, std::vector &chunk, int chunk_size, MPI_Comm comm); +void ExchangeWithLeft(int rank, std::vector &chunk, int chunk_size, MPI_Comm comm); +void EvenStep(int rank, int procs, std::vector &chunk, int chunk_size, MPI_Comm comm); +void OddStep(int rank, int procs, std::vector &chunk, int chunk_size, MPI_Comm comm); + +} // namespace klimov_m_shell_odd_even_merge diff --git a/tasks/klimov_m_shell_odd_even_merge/mpi/src/ops_mpi.cpp b/tasks/klimov_m_shell_odd_even_merge/mpi/src/ops_mpi.cpp new file mode 100644 index 00000000..a4659f04 --- /dev/null +++ b/tasks/klimov_m_shell_odd_even_merge/mpi/src/ops_mpi.cpp @@ -0,0 +1,216 @@ +#include "klimov_m_shell_odd_even_merge/mpi/include/ops_mpi.hpp" + +#include + +#include +#include +#include +#include +#include + +#include "klimov_m_shell_odd_even_merge/common/include/common.hpp" + +namespace klimov_m_shell_odd_even_merge { + +ShellBatcherMPI::ShellBatcherMPI(const InputType &input) { + SetTypeOfTask(GetStaticTypeOfTask()); + GetInput() = input; +} + +bool ShellBatcherMPI::ValidationImpl() { + return !GetInput().empty(); +} +bool ShellBatcherMPI::PreProcessingImpl() { + return true; +} +bool ShellBatcherMPI::PostProcessingImpl() { + return true; +} + +void ShellSortLocal(std::vector &data) { + const size_t len = data.size(); + for (size_t gap = len / 2; gap > 0; gap /= 2) { + for (size_t i = gap; i < len; ++i) { + int tmp = data[i]; + size_t j = i; + while (j >= gap && data[j - gap] > tmp) { + data[j] = data[j - gap]; + j -= gap; + } + data[j] = tmp; + } + } +} + +std::vector MergeEvenLeft(std::vector &left, std::vector &right, int chunk, int rank, MPI_Comm comm) { + std::vector left_even; + std::vector right_even; + left_even.reserve(chunk); + right_even.reserve(chunk); + + for (int k = 0; k < chunk; k += 2) { + left_even.push_back(left[k]); + right_even.push_back(right[k]); + } + + std::vector merged_even(left_even.size() + right_even.size()); + std::ranges::merge(left_even, right_even, merged_even.begin()); + + std::vector recv_odd((2 * static_cast(chunk)) - merged_even.size()); + MPI_Sendrecv(merged_even.data(), static_cast(merged_even.size()), MPI_INT, rank + 1, 0, recv_odd.data(), + static_cast(recv_odd.size()), MPI_INT, rank + 1, 0, comm, MPI_STATUS_IGNORE); + + std::vector result; + result.reserve(chunk); + if (chunk > 0) { + result.push_back(merged_even[0]); + } + + int idx = 0; + while (result.size() < static_cast(chunk)) { + int v1 = merged_even[idx + 1]; + int v2 = recv_odd[idx]; + if (v1 > v2) { + std::swap(v1, v2); + } + + result.push_back(v1); + if (result.size() < static_cast(chunk)) { + result.push_back(v2); + } + ++idx; + } + return result; +} + +std::vector MergeOddRight(std::vector &left, std::vector &right, int chunk, int rank, MPI_Comm comm) { + std::vector left_odd; + std::vector right_odd; + left_odd.reserve(chunk); + right_odd.reserve(chunk); + + for (int k = 1; k < chunk; k += 2) { + left_odd.push_back(left[k]); + right_odd.push_back(right[k]); + } + + std::vector merged_odd(left_odd.size() + right_odd.size()); + std::ranges::merge(left_odd, right_odd, merged_odd.begin()); + + std::vector recv_even((2 * static_cast(chunk)) - merged_odd.size()); + MPI_Sendrecv(merged_odd.data(), static_cast(merged_odd.size()), MPI_INT, rank - 1, 0, recv_even.data(), + static_cast(recv_even.size()), MPI_INT, rank - 1, 0, comm, MPI_STATUS_IGNORE); + + std::vector result; + result.reserve(chunk); + size_t idx = (chunk % 2 == 0) ? (static_cast(chunk) / 2) - 1 : (static_cast(chunk) - 1) / 2; + + if (chunk % 2 == 0) { + int v1 = recv_even[idx + 1]; + int v2 = merged_odd[idx]; + if (v1 > v2) { + std::swap(v1, v2); + } + result.push_back(v2); + ++idx; + } + + for (; idx + 1 < recv_even.size() && idx < merged_odd.size(); ++idx) { + int v1 = recv_even[idx + 1]; + int v2 = merged_odd[idx]; + if (v1 > v2) { + std::swap(v1, v2); + } + result.push_back(v1); + result.push_back(v2); + } + + while (idx + 1 < recv_even.size()) { + result.push_back(recv_even[++idx]); + } + while (idx < merged_odd.size()) { + result.push_back(merged_odd[idx++]); + } + + return result; +} + +void ExchangeWithRight(int rank, std::vector &chunk, int chunk_size, MPI_Comm comm) { + std::vector neighbor(chunk_size); + MPI_Sendrecv(chunk.data(), chunk_size, MPI_INT, rank + 1, 0, neighbor.data(), chunk_size, MPI_INT, rank + 1, 0, comm, + MPI_STATUS_IGNORE); + chunk = MergeEvenLeft(chunk, neighbor, chunk_size, rank, comm); +} + +void ExchangeWithLeft(int rank, std::vector &chunk, int chunk_size, MPI_Comm comm) { + std::vector neighbor(chunk_size); + MPI_Sendrecv(chunk.data(), chunk_size, MPI_INT, rank - 1, 0, neighbor.data(), chunk_size, MPI_INT, rank - 1, 0, comm, + MPI_STATUS_IGNORE); + chunk = MergeOddRight(neighbor, chunk, chunk_size, rank, comm); +} + +void EvenStep(int rank, int procs, std::vector &chunk, int chunk_size, MPI_Comm comm) { + if (procs % 2 != 0 && rank == procs - 1) { + return; + } + if (rank % 2 == 0) { + ExchangeWithRight(rank, chunk, chunk_size, comm); + } else { + ExchangeWithLeft(rank, chunk, chunk_size, comm); + } +} + +void OddStep(int rank, int procs, std::vector &chunk, int chunk_size, MPI_Comm comm) { + if (rank == 0 || (procs % 2 == 0 && rank == procs - 1)) { + return; + } + if (rank % 2 == 0) { + ExchangeWithLeft(rank, chunk, chunk_size, comm); + } else { + ExchangeWithRight(rank, chunk, chunk_size, comm); + } +} + +bool ShellBatcherMPI::RunImpl() { + int procs = 0; + int rank = 0; + MPI_Comm_size(MPI_COMM_WORLD, &procs); + MPI_Comm_rank(MPI_COMM_WORLD, &rank); + + std::vector global_data; + int total_elements = 0; + + if (rank == 0) { + global_data = GetInput(); + total_elements = static_cast(global_data.size()); + } + MPI_Bcast(&total_elements, 1, MPI_INT, 0, MPI_COMM_WORLD); + + int padding = (total_elements % procs == 0) ? 0 : (procs - (total_elements % procs)); + if (rank == 0) { + global_data.insert(global_data.end(), padding, std::numeric_limits::max()); + } + + int local_size = (total_elements + padding) / procs; + std::vector local_chunk(local_size); + MPI_Scatter(global_data.data(), local_size, MPI_INT, local_chunk.data(), local_size, MPI_INT, 0, MPI_COMM_WORLD); + + ShellSortLocal(local_chunk); + + for (int step = 0; step <= procs; ++step) { + if (step % 2 == 0) { + EvenStep(rank, procs, local_chunk, local_size, MPI_COMM_WORLD); + } else { + OddStep(rank, procs, local_chunk, local_size, MPI_COMM_WORLD); + } + } + + global_data.resize(total_elements + padding); + MPI_Allgather(local_chunk.data(), local_size, MPI_INT, global_data.data(), local_size, MPI_INT, MPI_COMM_WORLD); + + global_data.resize(total_elements); + GetOutput() = global_data; + return true; +} + +} // namespace klimov_m_shell_odd_even_merge diff --git a/tasks/klimov_m_shell_odd_even_merge/report.md b/tasks/klimov_m_shell_odd_even_merge/report.md new file mode 100644 index 00000000..2a0ec58d --- /dev/null +++ b/tasks/klimov_m_shell_odd_even_merge/report.md @@ -0,0 +1,65 @@ +# Сортировка Шелла с четно-нечетным слиянием Бэтчера + +- **Студент**: Климов Михаил Дмитриевич, группа 3823Б1ПР2 +- **Технология**: MPI / SEQ +- **Вариант**: 17 + +## 1. Введение +Цель работы – реализовать параллельную версию алгоритма сортировки Шелла с последующим слиянием отсортированных частей с использованием четно-нечетной сети Бэтчера. Данный подход позволяет эффективно сортировать данные на распределенной системе с помощью MPI. В качестве базовой последовательной сортировки используется сортировка Шелла, которая обладает хорошей локальностью и простотой реализации. Сеть Бэтчера обеспечивает слияние двух отсортированных массивов за логарифмическое число шагов. + +## 2. Постановка задачи +На вход подается одномерный массив целых чисел. Требуется отсортировать его по возрастанию с использованием параллельного алгоритма: +1. Исходный массив распределяется между MPI-процессами. +2. Каждый процесс выполняет сортировку Шелла своей локальной части. +3. Затем запускается итеративный процесс слияния по четно-нечетной схеме Бэтчера, в котором процессы обмениваются данными с соседями и выполняют слияние своих массивов. +4. После завершения всех итераций отсортированные части собираются на всех процессах, формируя итоговый отсортированный массив. + +Выходные данные – отсортированный массив целых чисел. + +## 3. Описание последовательного алгоритма +Последовательная версия реализована в классе `ShellBatcherSEQ`. Алгоритм представляет собой классическую сортировку Шелла: +- Выбирается последовательность шагов (gap), начиная с половины длины массива и уменьшаясь вдвое на каждой итерации. +- Для каждого шага выполняется сортировка вставками с данным шагом. +- Сложность алгоритма в среднем составляет O(n log² n). + +## 4. Схема распараллеливания (MPI) +Параллельная версия реализована в классе `ShellBatcherMPI`. Основные этапы: + +1. **Распределение данных**. Процесс с рангом 0 распределяет исходный массив между всеми процессами поровну (с возможным добавлением фиктивных элементов-заглушек `MAX_INT` для выравнивания). Используется `MPI_Scatter`. + +2. **Локальная сортировка**. Каждый процесс сортирует свою часть массива сортировкой Шелла (функция `ShellSortLocal`). + +3. **Четно-нечетное слияние Бэтчера**. Выполняется `procs` итераций (где `procs` – число процессов). На четных шагах: + - Процессы с четными рангами обмениваются данными с правым соседом и выполняют слияние четных элементов. + - Процессы с нечетными рангами обмениваются с левым соседом и выполняют слияние нечетных элементов. + На нечетных шагах направление обмена меняется. + Вспомогательные функции `MergeEvenLeft` и `MergeOddRight` реализуют слияние четных и нечетных подмассивов в соответствии с сетью Бэтчера. Обмен данными между процессами осуществляется через `MPI_Sendrecv`. + +4. **Сбор результатов**. После завершения всех итераций отсортированные части собираются на всех процессах с помощью `MPI_Allgather`, после чего удаляются добавленные ранее фиктивные элементы. + +## 5. Детали реализации +- Для выравнивания размеров локальных частей используются элементы `std::numeric_limits::max()`, которые гарантированно останутся в конце массива. +- Сортировка Шелла реализована итеративно с шагами, уменьшающимися вдвое. +- Слияние четных и нечетных подмассивов выполняется по алгоритму Бэтчера: сначала сливаются четные элементы двух соседних массивов, затем нечетные, после чего они перемежаются. +- Для обмена данными между соседними процессами используется `MPI_Sendrecv`, что позволяет избежать deadlock'ов. +- Тесты параметризованы размером данных и проверяют корректность сортировки для различных входных последовательностей, включая случайные, отсортированные и обратно отсортированные. + +## 6. Экспериментальная установка +- **Аппаратное обеспечение**: виртуальная среда (контейнер Docker) с выделением 4 ядер и 8 ГБ ОЗУ. +- **ОС**: Ubuntu 24.04 LTS (внутри контейнера). +- **Компилятор**: g++-14. +- **Сборка**: CMake с типом `Release`, санитайзеры не использовались. +- **Среда выполнения**: MPI-тесты запускались с `PPC_NUM_PROC=2`, `4` через скрипт `scripts/run_tests.py`. Для тестов производительности использовался массив из 3 миллионов элементов. + +## 7. Результаты и обсуждение + +### 7.1 Корректность + +Все тесты успешно проходятся как для последовательной, так и для MPI-версии, что подтверждает корректность реализации. + +## 8. Выводы +Разработана MPI-программа, реализующая параллельную сортировку массива с использованием сортировки Шелла и сети четно-нечетного слияния Бэтчера. Программа корректно обрабатывает массивы произвольного размера и демонстрирует хорошую масштабируемость. Реализация полностью соответствует условиям задачи и может быть использована для сортировки больших объемов данных на кластерных системах. + +## 9. Источники +1. Microsoft MPI : документация // Microsoft Learn. – URL: https://learn.microsoft.com/ru-ru/message-passing-interface/microsoft-mpi +2. Сысоев А. В. Курс лекций по параллельному программированию diff --git a/tasks/klimov_m_shell_odd_even_merge/seq/include/ops_seq.hpp b/tasks/klimov_m_shell_odd_even_merge/seq/include/ops_seq.hpp new file mode 100644 index 00000000..0bbdfb17 --- /dev/null +++ b/tasks/klimov_m_shell_odd_even_merge/seq/include/ops_seq.hpp @@ -0,0 +1,21 @@ +#pragma once + +#include "klimov_m_shell_odd_even_merge/common/include/common.hpp" +#include "task/include/task.hpp" + +namespace klimov_m_shell_odd_even_merge { + +class ShellBatcherSEQ : public BaseTask { + public: + static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() { + return ppc::task::TypeOfTask::kSEQ; + } + explicit ShellBatcherSEQ(const InputType &input); + + bool ValidationImpl() override; + bool PreProcessingImpl() override; + bool RunImpl() override; + bool PostProcessingImpl() override; +}; + +} // namespace klimov_m_shell_odd_even_merge diff --git a/tasks/klimov_m_shell_odd_even_merge/seq/src/ops_seq.cpp b/tasks/klimov_m_shell_odd_even_merge/seq/src/ops_seq.cpp new file mode 100644 index 00000000..354ab5be --- /dev/null +++ b/tasks/klimov_m_shell_odd_even_merge/seq/src/ops_seq.cpp @@ -0,0 +1,45 @@ +#include "klimov_m_shell_odd_even_merge/seq/include/ops_seq.hpp" + +#include +#include + +#include "klimov_m_shell_odd_even_merge/common/include/common.hpp" + +namespace klimov_m_shell_odd_even_merge { + +ShellBatcherSEQ::ShellBatcherSEQ(const InputType &input) { + SetTypeOfTask(GetStaticTypeOfTask()); + GetInput() = input; +} + +bool ShellBatcherSEQ::ValidationImpl() { + return !GetInput().empty(); +} +bool ShellBatcherSEQ::PreProcessingImpl() { + return true; +} +bool ShellBatcherSEQ::PostProcessingImpl() { + return true; +} + +bool ShellBatcherSEQ::RunImpl() { + std::vector data = GetInput(); + const size_t n = data.size(); + + for (size_t gap = n / 2; gap > 0; gap /= 2) { + for (size_t i = gap; i < n; ++i) { + int tmp = data[i]; + size_t j = i; + while (j >= gap && data[j - gap] > tmp) { + data[j] = data[j - gap]; + j -= gap; + } + data[j] = tmp; + } + } + + GetOutput() = data; + return true; +} + +} // namespace klimov_m_shell_odd_even_merge diff --git a/tasks/klimov_m_shell_odd_even_merge/settings.json b/tasks/klimov_m_shell_odd_even_merge/settings.json new file mode 100644 index 00000000..16f25e42 --- /dev/null +++ b/tasks/klimov_m_shell_odd_even_merge/settings.json @@ -0,0 +1,7 @@ +{ + "tasks": { + "mpi": "enabled", + "seq": "enabled" + }, + "tasks_type": "processes" +} diff --git a/tasks/klimov_m_shell_odd_even_merge/tests/functional/main.cpp b/tasks/klimov_m_shell_odd_even_merge/tests/functional/main.cpp new file mode 100644 index 00000000..72848564 --- /dev/null +++ b/tasks/klimov_m_shell_odd_even_merge/tests/functional/main.cpp @@ -0,0 +1,69 @@ +#include + +#include +#include +#include +#include +#include +#include + +#include "klimov_m_shell_odd_even_merge/common/include/common.hpp" +#include "klimov_m_shell_odd_even_merge/mpi/include/ops_mpi.hpp" +#include "klimov_m_shell_odd_even_merge/seq/include/ops_seq.hpp" +#include "util/include/func_test_util.hpp" +#include "util/include/util.hpp" + +namespace klimov_m_shell_odd_even_merge { + +class ShellBatcherFuncTest : public ppc::util::BaseRunFuncTests { + public: + static std::string PrintTestParam(const TestParam &test_param) { + size_t dot_pos = test_param.find('.'); + return test_param.substr(0, dot_pos); + } + + protected: + void SetUp() override { + TestParam file_name = std::get(ppc::util::GTestParamIndex::kTestParams)>(GetParam()); + std::string full_path = ppc::util::GetAbsoluteTaskPath(PPC_ID_klimov_m_shell_odd_even_merge, file_name); + std::ifstream fin(full_path); + + int val = 0; + while (fin >> val) { + input_data_.push_back(val); + } + fin.close(); + } + + bool CheckTestOutputData(OutputType &out_data) final { + return std::ranges::is_sorted(out_data); + } + + InputType GetTestInputData() final { + return input_data_; + } + + private: + InputType input_data_; +}; + +namespace { + +TEST_P(ShellBatcherFuncTest, TestFromFiles) { + ExecuteTest(GetParam()); +} + +const std::array kTestFiles = {"test1.txt", "test2.txt", "test3.txt"}; + +const auto kTaskList = std::tuple_cat( + ppc::util::AddFuncTask(kTestFiles, PPC_SETTINGS_klimov_m_shell_odd_even_merge), + ppc::util::AddFuncTask(kTestFiles, PPC_SETTINGS_klimov_m_shell_odd_even_merge)); + +const auto kTestValues = ppc::util::ExpandToValues(kTaskList); +const auto kNamePrinter = ShellBatcherFuncTest::PrintFuncTestName; + +INSTANTIATE_TEST_SUITE_P(ShellBatcherFunctionalTests, ShellBatcherFuncTest, kTestValues, kNamePrinter); + +} // namespace + +} // namespace klimov_m_shell_odd_even_merge diff --git a/tasks/klimov_m_shell_odd_even_merge/tests/performance/main.cpp b/tasks/klimov_m_shell_odd_even_merge/tests/performance/main.cpp new file mode 100644 index 00000000..f5219d8e --- /dev/null +++ b/tasks/klimov_m_shell_odd_even_merge/tests/performance/main.cpp @@ -0,0 +1,50 @@ +#include + +#include +#include + +#include "klimov_m_shell_odd_even_merge/common/include/common.hpp" +#include "klimov_m_shell_odd_even_merge/mpi/include/ops_mpi.hpp" +#include "klimov_m_shell_odd_even_merge/seq/include/ops_seq.hpp" +#include "util/include/perf_test_util.hpp" + +namespace klimov_m_shell_odd_even_merge { + +class ShellBatcherPerfTest : public ppc::util::BaseRunPerfTests { + const size_t kDataSize_ = 3000000; + InputType perf_input_; + + protected: + void SetUp() override { + perf_input_.resize(kDataSize_); + for (size_t i = 0; i < kDataSize_; ++i) { + perf_input_[i] = static_cast(kDataSize_ - i); + } + } + + bool CheckTestOutputData(OutputType &out_data) final { + return std::ranges::is_sorted(out_data); + } + + InputType GetTestInputData() final { + return perf_input_; + } +}; + +namespace { + +TEST_P(ShellBatcherPerfTest, MeasurePerformance) { + ExecuteTest(GetParam()); +} + +const auto kAllPerfTasks = ppc::util::MakeAllPerfTasks( + PPC_SETTINGS_klimov_m_shell_odd_even_merge); + +const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks); +const auto kNameGen = ShellBatcherPerfTest::CustomPerfTestName; + +INSTANTIATE_TEST_SUITE_P(ShellBatcherPerformanceTests, ShellBatcherPerfTest, kGtestValues, kNameGen); + +} // namespace + +} // namespace klimov_m_shell_odd_even_merge diff --git a/tasks/morozova_s_broadcast/info.json b/tasks/morozova_s_broadcast/info.json index 6e00e955..37cfff3a 100644 --- a/tasks/morozova_s_broadcast/info.json +++ b/tasks/morozova_s_broadcast/info.json @@ -1,9 +1,9 @@ { "student": { - "first_name": "\u0421\u043e\u0444\u044c\u044f", - "group_number": "3823\u04111\u0424\u04182", - "last_name": "\u041c\u043e\u0440\u043e\u0437\u043e\u0432\u0430", - "middle_name": "\u0410\u043d\u0434\u0440\u0435\u0435\u0432\u043d\u0430", + "first_name": "Софья", + "group_number": "3823Б1ФИ2", + "last_name": "Морозова", + "middle_name": "Андреевна", "task_number": "2" } } diff --git a/tasks/morozova_s_connected_components/info.json b/tasks/morozova_s_connected_components/info.json index bfc872ee..7c61f3e8 100644 --- a/tasks/morozova_s_connected_components/info.json +++ b/tasks/morozova_s_connected_components/info.json @@ -1,9 +1,9 @@ { "student": { - "first_name": "\u0421\u043e\u0444\u044c\u044f", - "group_number": "3823\u04111\u0424\u04182", - "last_name": "\u041c\u043e\u0440\u043e\u0437\u043e\u0432\u0430", - "middle_name": "\u0410\u043d\u0434\u0440\u0435\u0435\u0432\u043d\u0430", + "first_name": "Софья", + "group_number": "3823Б1ФИ2", + "last_name": "Морозова", + "middle_name": "Андреевна", "task_number": "3" } } diff --git a/tasks/morozova_s_matrix_max_value/info.json b/tasks/morozova_s_matrix_max_value/info.json index 6093ef36..55b1dd62 100644 --- a/tasks/morozova_s_matrix_max_value/info.json +++ b/tasks/morozova_s_matrix_max_value/info.json @@ -1,9 +1,9 @@ { "student": { - "first_name": "\u0421\u043e\u0444\u044c\u044f", - "group_number": "3823\u04111\u0424\u04182", - "last_name": "\u041c\u043e\u0440\u043e\u0437\u043e\u0432\u0430", - "middle_name": "\u0410\u043d\u0434\u0440\u0435\u0435\u0432\u043d\u0430", + "first_name": "Софья", + "group_number": "3823Б1ФИ2", + "last_name": "Морозова", + "middle_name": "Андреевна", "task_number": "1" } } diff --git a/tasks/sabutay_a_increasing_contrast/info.json b/tasks/sabutay_a_increasing_contrast/info.json index dc0cc8e1..48cfe931 100644 --- a/tasks/sabutay_a_increasing_contrast/info.json +++ b/tasks/sabutay_a_increasing_contrast/info.json @@ -1,7 +1,7 @@ { - "first_name": "\u0421\u0430\u0431\u0443\u0442\u0430\u0439", - "group_number": "3823\u04111\u041f\u04205", - "last_name": "\u0418\u043c\u0430\u043d\u043e\u0432", - "middle_name": "\u0428\u0438\u0440\u0437\u0430\u0434 \u043e\u0433\u043b\u044b", + "first_name": "Сабутай", + "group_number": "3823Б1ПР5", + "last_name": "Иманов", + "middle_name": "Ширзад оглы", "task_number": "2" } diff --git a/tasks/sabutay_a_radix_sort_double_with_merge/info.json b/tasks/sabutay_a_radix_sort_double_with_merge/info.json index e80b9e1a..0f1b1d1c 100644 --- a/tasks/sabutay_a_radix_sort_double_with_merge/info.json +++ b/tasks/sabutay_a_radix_sort_double_with_merge/info.json @@ -1,7 +1,7 @@ { - "first_name": "\u0421\u0430\u0431\u0443\u0442\u0430\u0439", - "group_number": "3823\u04111\u041f\u04205", - "last_name": "\u0418\u043c\u0430\u043d\u043e\u0432", - "middle_name": "\u0428\u0438\u0440\u0437\u0430\u0434 \u043e\u0433\u043b\u044b", + "first_name": "Сабутай", + "group_number": "3823Б1ПР5", + "last_name": "Иманов", + "middle_name": "Ширзад оглы", "task_number": "3" } diff --git a/tasks/sabutay_vector_sign_changes/info.json b/tasks/sabutay_vector_sign_changes/info.json index 42452825..522356e0 100644 --- a/tasks/sabutay_vector_sign_changes/info.json +++ b/tasks/sabutay_vector_sign_changes/info.json @@ -1,9 +1,9 @@ { "student": { - "first_name": "\u0421\u0430\u0431\u0443\u0442\u0430\u0439", - "group_number": "3823\u04111\u041f\u04205", - "last_name": "\u0418\u043c\u0430\u043d\u043e\u0432", - "middle_name": "\u0428\u0438\u0440\u0437\u0430\u0434 \u043e\u0433\u043b\u044b", + "first_name": "Сабутай", + "group_number": "3823Б1ПР5", + "last_name": "Иманов", + "middle_name": "Ширзад оглы", "task_number": "1" } } diff --git a/tasks/shkryleva_s_vec_min_val/info.json b/tasks/shkryleva_s_vec_min_val/info.json index 4bd27939..fd300eec 100644 --- a/tasks/shkryleva_s_vec_min_val/info.json +++ b/tasks/shkryleva_s_vec_min_val/info.json @@ -1,9 +1,9 @@ { "student": { - "first_name": "\u0421\u0432\u0435\u0442\u043b\u0430\u043d\u0430", - "group_number": "3823\u04111\u041f\u04201", - "last_name": "\u0428\u043a\u0440\u044b\u043b\u0451\u0432\u0430", - "middle_name": "\u0410\u043b\u0435\u043a\u0441\u0435\u0435\u0432\u043d\u0430", + "first_name": "Светлана", + "group_number": "3823Б1ПР1", + "last_name": "Шкрылёва", + "middle_name": "Алексеевна", "task_number": "1" } } diff --git a/tasks/tsarkov_k_lexicographic_string_compare/info.json b/tasks/tsarkov_k_lexicographic_string_compare/info.json index a8c2a295..05ad5f47 100644 --- a/tasks/tsarkov_k_lexicographic_string_compare/info.json +++ b/tasks/tsarkov_k_lexicographic_string_compare/info.json @@ -1,7 +1,7 @@ { "student": { "first_name": "Klim", - "group_number": "3823\u04111\u041f\u04204", + "group_number": "3823Б1ПР4", "last_name": "Tsarkov", "middle_name": "Alexandrovich", "task_number": "1" diff --git a/tasks/yushkova_p_min_in_matrix/info.json b/tasks/yushkova_p_min_in_matrix/info.json index 19703457..9f2da1d7 100644 --- a/tasks/yushkova_p_min_in_matrix/info.json +++ b/tasks/yushkova_p_min_in_matrix/info.json @@ -1,9 +1,9 @@ { "student": { - "first_name": "\u041f\u043e\u043b\u0438\u043d\u0430", - "group_number": "3823\u04111\u041f\u04202", - "last_name": "\u042e\u0448\u043a\u043e\u0432\u0430", - "middle_name": "\u0410\u043b\u0435\u043a\u0441\u0430\u043d\u0434\u0440\u043e\u0432\u043d\u0430", + "first_name": "Полина", + "group_number": "3823Б1ПР2", + "last_name": "Юшкова", + "middle_name": "Александровна", "task_number": "1" } } diff --git a/tasks/zyuzin_n_sum_elements_of_matrix/info.json b/tasks/zyuzin_n_sum_elements_of_matrix/info.json index a2559424..b8774ece 100644 --- a/tasks/zyuzin_n_sum_elements_of_matrix/info.json +++ b/tasks/zyuzin_n_sum_elements_of_matrix/info.json @@ -1,9 +1,9 @@ { "student": { - "first_name": "\u041d\u0438\u043a\u0438\u0442\u0430", - "group_number": "3823\u04111\u041f\u04202", - "last_name": "\u0417\u044e\u0437\u0438\u043d", - "middle_name": "\u041c\u0438\u0445\u0430\u0439\u043b\u043e\u0432\u0438\u0447", + "first_name": "Никита", + "group_number": "3823Б1ПР2", + "last_name": "Зюзин", + "middle_name": "Михайлович", "task_number": "1" } }