Загрузка ядер при паралельных вычислениях

@Barrent · Регистрация: 04.05.2013

Студворк — интернет-сервис помощи студентам

Имеем: Phenom II x4 B50
Задача: Параллельно посчитать произведение/сумму матриц/векторов . Алгоритм использован наипростейший - базовый (в некоторых книгах ленточным обзывают).
Если в диспетчере для процесса отрубить 1 ядро, то все 3 грузятся без проблем на 100%.
Если запустить на всех ядрах, то загрузка начинает плавать на всех ядрах от ~70% до ~90%.
Повышение приоритета процесса через диспетчер вносит вообще полный хаос в загрузку ядер.
Проблема в том, что при использовании и 3-х и 4-х ядер время вычисления толком не меняется.

Как можно решить сию проблему?
Кусок кода, касающегося всего воздействия на потоки.

C++
1
2
3
4
5
6
7
8
9
Threads[0] = CreateThread(NULL, 0, Thread0_Function, new DWORD(0), 0, NULL);    
CloseHandle(Threads[0]);
Threads[1] = CreateThread(NULL, 0, Thread1_Function, new DWORD(1), 0, NULL);    
CloseHandle(Threads[1]);
Threads[2] = CreateThread(NULL, 0, Thread2_Function, new DWORD(2), 0, NULL);    
Threads[3] = CreateThread(NULL, 0, Thread3_Function, new DWORD(3), 0, NULL);    
CloseHandle(Threads[3]);
WaitForSingleObject(Threads[2], INFINITE);
CloseHandle(Threads[2]);

Убежденный · 08.10.2014, 01:22

Сообщение от Barrent

Если в диспетчере для процесса отрубить 1 ядро, то все 3 грузятся без проблем на 100%.
Если запустить на всех ядрах, то загрузка начинает плавать на всех ядрах от ~70% до ~90%.

Значит, процессорам "мало еды", или они спят где-то, в ожидании друг друга,
или еще чего-нибудь. Имея перед глазами код, можно было бы сказать больше.

Сообщение от Barrent

Повышение приоритета процесса через диспетчер вносит вообще полный хаос в загрузку ядер.

Потому что приоритеты придумали не для этого.
А для того, чтобы сообщить системе, работа какого потока/процесса более важна, а
какого менее. Для нагруженных сценариев типа 100% CPU на всех ядрах игры с
приоритетами ничего не дадут. Как и игры с affinity mask (привязка потоков/процессов к
логическим/физическим CPU/Cores/HT-Threads).

Сообщение от Barrent

Проблема в том, что при использовании и 3-х и 4-х ядер время вычисления толком не меняется.

Для начала объясните, почему вы ждете завершения только одного потока, а не всех ?

C++
1
WaitForSingleObject(Threads[2], INFINITE);

@Barrent · 08.10.2014, 01:42 **[ТС]**

Убежденный,
Поток номер 2 занимается выводом результата. Ожидание других потоков происходит внутри потока 2.
Весь код в 1 сообщение не влезает.

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include "stdafx.h"
#include <windows.h>
#include <iostream>
#include <iomanip>
#include <time.h>
#include <conio.h>
#include "Matrix.h"
 
using std::wcout;
using std::endl;
using std::setw;
using Matrix::ELEMENT;
 
const DWORD P = 4;                                  //Кількість потоків
 
ELEMENT A[Matrix::N];                               //Вектор А
ELEMENT B[Matrix::N];                               //Вектор В
ELEMENT C[Matrix::N];                               //Вектор C
ELEMENT MO[Matrix::N][Matrix::N];                   //Матриця МО
ELEMENT MK[Matrix::N][Matrix::N];                   //Матриця МК
ELEMENT MOMK[Matrix::N][Matrix::N];                 //Результат множення МО*МК
 
HANDLE mutC, mutMK;                                 //Мьютекси доступу до спільних ресурсів: вектору C та матриці МК
HANDLE SemaphoresA[P];                              //Семафори завершення обчислення A потоками
HANDLE SemaphoresMOMK[P];                           //Семафори завершення обчислення MOMK потоками
HANDLE SemaphoresData[P];                           //Семафори завершення вводу початкових даних
 
DWORD WINAPI Thread0_Function(LPVOID lpParam);      //Вхідна функція потоку 0
DWORD WINAPI Thread1_Function(LPVOID lpParam);      //Вхідна функція потоку 1
DWORD WINAPI Thread2_Function(LPVOID lpParam);      //Вхідна функція потоку 2
DWORD WINAPI Thread3_Function(LPVOID lpParam);      //Вхідна функція потоку 3
 
void InitLocale();
 
int _tmain(int argc, _TCHAR* argv[]){       
    InitLocale();                                           //Налаштування консолі для вводу/виводу кирилиці
    HANDLE Threads[P];                                      //Масив потоків
    //Створення мьютексів
    mutC = CreateMutex(NULL, FALSE, TEXT("B"));             //Мьютекс доступу до ресурсу C
    mutMK = CreateMutex(NULL, FALSE, TEXT("MK"));           //Мьютекс доступу до ресурсу МК
    //Створення семафорів
    for (size_t i = 0; i < P; i++){
        SemaphoresData[i] = CreateSemaphore(NULL, 0, P, NULL);      //Семафори вводу даних
        SemaphoresMOMK[i] = CreateSemaphore(NULL, 0, P, NULL);      //Семафори обчислення добутку матриць МО та МК
        SemaphoresA[i] = CreateSemaphore(NULL, 0, P, NULL);         //Семафори обчислення вектору А
    }       
    wcout << TEXT("Для початку обчислення натисніть будь-яку клавішу...") << endl;
    _getch();
    wcout << TEXT("Будь-ласка, зачекайте завершення обчислення...") << endl;
    //Створення процесів   
    Threads[0] = CreateThread(NULL, 0, Thread0_Function, new DWORD(0), 0, NULL);    //Ініціація потоку 0
    CloseHandle(Threads[0]);
    Threads[1] = CreateThread(NULL, 0, Thread1_Function, new DWORD(1), 0, NULL);    //Ініціація потоку 1
    CloseHandle(Threads[1]);
    Threads[2] = CreateThread(NULL, 0, Thread2_Function, new DWORD(2), 0, NULL);    //Ініціація потоку 2
    Threads[3] = CreateThread(NULL, 0, Thread3_Function, new DWORD(3), 0, NULL);    //Ініціація потоку 3
    CloseHandle(Threads[3]);
    WaitForSingleObject(Threads[2], INFINITE);
    CloseHandle(Threads[2]);    
    system("pause");
    return 0;
}

@Barrent · 08.10.2014, 01:45 **[ТС]**

Защита условно общих данных мьютексами - условие курсовой.
В математических функция мьютексов и семафоров нет, так что их не выкладываю.
Размер матриц 2000х2000

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
DWORD WINAPI Thread0_Function(LPVOID lpParam){
    DWORD serial = *(static_cast<LPDWORD>(lpParam));
    ELEMENT C_copy[Matrix::N];                          //Копія вектору C
 
    //wcout << TEXT("Потік 0: Генерація матриць МО та МК...\n") << endl;
    //Введення МО
    Matrix::GenerateMatrix(MO[0]);
    //Введення МК
    Matrix::GenerateMatrix(MK[0]);
    //Повідомити про власне введення даних
    //wcout << TEXT("Потік 0: Дані введено!\n") << endl;
    ReleaseSemaphore(SemaphoresData[serial], P, NULL);      
    //Чекати введення всіх даних
    WaitForMultipleObjects(P, SemaphoresData, TRUE, INFINITE);
    //wcout << TEXT("Потік 0: Сигнал про введення всіх початкові даних отримано!\n") << endl;
 
    //Чекати доступу до вектору С
    WaitForSingleObject(mutC, INFINITE);
    //Копіювання C
    Matrix::CopyVector(C_copy, C);  
    //Повідомити про вільний доступ до вектору С
    ReleaseMutex(mutC); 
    //wcout << TEXT("Потік 0: Копіювання вектору С виконано!\n") << endl;
 
    //Обчислення своєї частини МОМК базовым методом
    WaitForSingleObject(mutMK, INFINITE);
    Matrix::MatrixMatrix(serial, P, MOMK[0], MO[0], MK[0]);
    ReleaseMutex(mutMK);    
    //Повідомити про власне обчислення МОМК
    ReleaseSemaphore(SemaphoresMOMK[serial], P, NULL);
    //wcout << TEXT("Потік 0: Обчислення МКМОн завершено!\n") << endl;
    //Чекати повне обчислення МОМК
    WaitForMultipleObjects(P, SemaphoresMOMK, TRUE, INFINITE);
    //wcout << TEXT("Потік 0: Сигнал про завершення спільного обчислення МОМК отримано!\n") << endl;
 
    //Обчислення своєї частини А
    Matrix::CalculateA(serial, P, A, B, C_copy, MOMK[0]);
    //wcout << TEXT("Потік 0: Обчислення Ан завершено!\n") << endl;
    //Повідомити про власне обчислення А
    ReleaseSemaphore(SemaphoresA[serial], P, NULL);
    
    //wcout << TEXT("Потік 0: ==================Завершено!\n") << endl;
    return 0;
}
DWORD WINAPI Thread1_Function(LPVOID lpParam){
    DWORD serial = *(static_cast<LPDWORD>(lpParam));
    ELEMENT C_copy[Matrix::N];                              //Копія вектору C
    ELEMENT MK_copy[Matrix::N][Matrix::N];                  //Копія матриці МК
    ReleaseSemaphore(SemaphoresData[1], P, NULL);           //Потік 1 не вводить дані 
 
    //Чекати введення всіх даних
    WaitForMultipleObjects(P, SemaphoresData, TRUE, INFINITE);
    //wcout << TEXT("Потік 1: Сигнал про введення всіх початкові даних отримано!\n") << endl;
 
    //Чекати доступу до матриці МК
    WaitForSingleObject(mutMK, INFINITE);
    //Копіювання МК
    Matrix::CopyMatrix(MK_copy[0], MK[0]);  
    //Повідомити про вільний доступ до матриці МК
    ReleaseMutex(mutMK);
    //wcout << TEXT("Потік 1: Копіювання матриці МК завершено!\n") << endl;
 
    //Чекати доступу до вектору С
    WaitForSingleObject(mutC, INFINITE);
    //Копіювання C
    Matrix::CopyVector(C_copy, C);  
    //Повідомити про вільний доступ до вектору С
    ReleaseMutex(mutC);
    //wcout << TEXT("Потік 1: Копіювання вектору С завершено!\n") << endl;
 
    //Обчислення своєї частини МОМК базовым методом
    Matrix::MatrixMatrix(serial, P, MOMK[0], MO[0], MK_copy[0]);
    //Повідомити про власне обчислення МОМК
    ReleaseSemaphore(SemaphoresMOMK[serial], P, NULL);
    //wcout << TEXT("Потік 1: Обчислення МКМОн завершено!\n") << endl;
    //Чекати повне обчислення МОМК
    WaitForMultipleObjects(P, SemaphoresMOMK, TRUE, INFINITE);
    //wcout << TEXT("Потік 1: Сигнал про завершення спільного обчислення МОМК отримано!\n") << endl;
 
    //Обчислення своєї частини А
    Matrix::CalculateA(serial, P, A, B, C_copy, MOMK[0]);   
    //Повідомити про власне обчислення А
    ReleaseSemaphore(SemaphoresA[serial], P, NULL);
    //wcout << TEXT("Потік 1: Обчислення Ан завершено!\n") << endl;
 
    //wcout << TEXT("Потік 1: ==================Завершено!\n") << endl;
 
    return 0;
}
DWORD WINAPI Thread2_Function(LPVOID lpParam){
    DWORD serial = *(static_cast<LPDWORD>(lpParam));
    ELEMENT C_copy[Matrix::N];                              //Копія вектору C
    ELEMENT MK_copy[Matrix::N][Matrix::N];                  //Копія матриці МК
    
    //Введення B
    //wcout << TEXT("Потік 2: Генерація вектору B...\n") << endl;
    Matrix::GenerateVector(B);  
    
    //Повідомити про введення даних
    //wcout << TEXT("Потік 2: Дані введено!\n") << endl;
    ReleaseSemaphore(SemaphoresData[serial], P, NULL);
    
    //Чекати введення всіх даних
    WaitForMultipleObjects(P, SemaphoresData, TRUE, INFINITE);
    //wcout << TEXT("Потік 2: Сигнал про введення всіх початкові даних отримано!\n") << endl;
    
    clock_t start = clock();                                    //початок відліку часу
 
    //Чекати доступу до матриці МК
    WaitForSingleObject(mutMK, INFINITE);
    //Копіювання МК
    Matrix::CopyMatrix(MK_copy[0], MK[0]);  
    //Повідомити про вільний доступ до матриці МК
    ReleaseMutex(mutMK);
    //wcout << TEXT("Потік 2: Копіювання матриці МК завершено!\n") << endl;
 
    //Чекати доступу до вектору С
    WaitForSingleObject(mutC, INFINITE);
    //Копіювання C
    Matrix::CopyVector(C_copy, C);
    //Повідомити про вільний доступ до вектору С
    ReleaseMutex(mutC);
    //wcout << TEXT("Потік 2: Копіювання вектору С завершено!\n") << endl;
 
    //Обчислення своєї частини МОМК базовим методом
    Matrix::MatrixMatrix(serial, P, MOMK[0], MO[0], MK_copy[0]);
    //Повідомити про власне обчислення МОМК
    ReleaseSemaphore(SemaphoresMOMK[serial], P, NULL);
    //wcout << TEXT("Потік 2: Обчислення матриці МОМКн завершено!\n") << endl;
    //Чекати повне обчислення МОМК
    WaitForMultipleObjects(P, SemaphoresMOMK, TRUE, INFINITE);
    //wcout << TEXT("Потік 2: Сигнал про завершення спільного обчислення матриці МОМК отримано!\n") << endl;
 
    //Обчислення своєї частини А
    Matrix::CalculateA(serial, P, A, B, C_copy, MOMK[0]);
    //Повідомити про власне обчислення А
    ReleaseSemaphore(SemaphoresA[serial], P, NULL);
    //wcout << TEXT("Потік 2: Обчислення Ан завершено!\n") << endl;
    //Чекати повне обчислення A
    WaitForMultipleObjects(P, SemaphoresA, TRUE, INFINITE);
    //wcout << TEXT("Потік 2: Сигнал про завершення спільного обчислення вектору А отримано!\n") << endl;
    //Вивід вектору А
 
    /*
    wcout << TEXT("Вектор В:") << endl;
    Matrix::PrintVector(B);
    wcout << TEXT("Вектор C:") << endl;
    Matrix::PrintVector(C_copy);
    wcout << TEXT("Матриця МО:") << endl;
    Matrix::PrintMatrix(MO[0]);
    wcout << TEXT("Матриця МK:") << endl;
    Matrix::PrintMatrix(MK_copy[0]);
    wcout << TEXT("Матриця МOMK:") << endl;
    Matrix::PrintMatrix(MOMK[0]);*/
    
    clock_t finish = clock();
    wcout << TEXT("Потік 2: Повне обчислення вектору А тривало ") << finish - start << TEXT(" мілісекунд!") << endl;
    wcout << TEXT("Потік 2: Вектор A:") << endl;
//  Matrix::PrintVector(A);
    
    //wcout << TEXT("Потік 2: ==================Завершено!\n") << endl;
    return 0;
}
DWORD WINAPI Thread3_Function(LPVOID lpParam){
    DWORD serial = *(static_cast<LPDWORD>(lpParam));
    ELEMENT MK_copy[Matrix::N][Matrix::N];                  //Копія матриці МК
 
    //Введення C
    //wcout << TEXT("Потік 3: Генерація вектору С...\n") << endl;
    Matrix::GenerateVector(C);
    //Повідомити про власне введення даних
    ////wcout << TEXT("Потік 3: Дані введено!\n");
    ReleaseSemaphore(SemaphoresData[serial], P, NULL);  
    //Чекати введення всіх даних
    WaitForMultipleObjects(P, SemaphoresData, TRUE, INFINITE);
    //wcout << TEXT("Потік 3: Сигнал про введення всіх початкові даних отримано!\n") << endl;
 
    //Чекати доступу до матриці МК
    WaitForSingleObject(mutMK, INFINITE);
    //Копіювання МК
    Matrix::CopyMatrix(MK_copy[0], MK[0]);
    //Повідомити про вільний доступ до матриці МК
    ReleaseMutex(mutMK);
    //wcout << TEXT("Потік 3: Копіювання матриці МК завершено!\n") << endl;
 
    //Обчислення своєї частини МОМК базовым методом
    Matrix::MatrixMatrix(serial, P, MOMK[0], MO[0], MK_copy[0]);
    //Повідомити про власне обчислення МОМК
    ReleaseSemaphore(SemaphoresMOMK[serial], P, NULL);
    //Чекати повне обчислення МОМК
    WaitForMultipleObjects(P, SemaphoresMOMK, TRUE, INFINITE);
    //wcout << TEXT("Потік 3: Обчислення матриці МОМКн завершено!\n") << endl;
 
    //Обчислення своєї частини А
    WaitForSingleObject(mutC, INFINITE);
    Matrix::CalculateA(serial, P, A, B, C, MOMK[0]);
    ReleaseMutex(mutC);
    //Повідомити про власне обчислення А
    ReleaseSemaphore(SemaphoresA[serial], P, NULL);
    //wcout << TEXT("Потік 2: Обчислення Ан завершено!\n") << endl;
    
    //wcout << TEXT("Потік 3: ==================Завершено!\n") << endl;
    return 0;
}

Убежденный · 08.10.2014, 01:57

Что бросается в глаза:

1) Обилие объектов ядра (мьютексы, семафоры) и функций работы с ними.
А это очень дорогие ресурсы. Один вызов Wait - это переключение в ядро,
затем suspend/resume потока, затем возврат обратно. Тысячи и тысячи тактов.
Будет быстрее работать, если просто тупо переписать на критических
секциях, спин-локах и других "легковесных" механизмах.

2) "Гранулярность" блокировки ресурса должна быть минимальной.
Вот здесь

C++
1
2
3
WaitForSingleObject(mutC, INFINITE);
Matrix::CalculateA(serial, P, A, B, C, MOMK[0]);
ReleaseMutex(mutC);

наблюдается противоположная картина: мьютекс захватывается
на время выполнения CalculateA. Чем дольше CalculateA, тем
длиннее ожидание других потоков на этом мьютексе.
А где же параллельность тогда ?

3) Имена - это полная жесть.
При виде "Matrix::CalculateA(serial, P, A, B, C, MOMK[0]);" любого нормального
программиста будет бросать в дрожь. Что такое B, например ? А MOMK ?
И что именно делает функция со странным названием "CalculateA" ?
Имена должны быть осмысленные. Я вот всматривался в этот код минут 10,
но так толком не понял, для чего там все эти wait/release/momk и т.п.
Хотя может быть, время суток (ночь) сказывается...

@Barrent · 08.10.2014, 10:46 **[ТС]**

Задача: A = B + C * (MO * MK)
А, В, С - вектора
МО, МК - матрицы

Поток 0 - генерация МО и МК, расчеты.
Поток 1 - только расчеты
Поток 2 - Генерация В, вывод А, расчеты.
Поток 3 - генерация С, расчеты.

Краткий алгоритм:
Ввели данные.
Каждый поток освободил свой семафор ввода данных
Каждый поток ждет пока введут все данные
Сделали себе по копии условно общих данных по защитой мьютексов
Каждый поток посчитал свою часть МО*МК
Каждый поток освободил свой семафор расчета МО*МК
Все потоки подождали полного расчета МОМК
Каждый поток посчитал свою часть А
Каждый поток освободил свой семафор расчета А
Поток 2 подождал пока все посчитают.
Поток 2 вывел результат.

Добавлено через 1 минуту
Убежденный, Пока печатал условие, прошло 5 минут и редатирование поста закрыли. Пока перепечатал - еще время прошло. Сорри

Использование только мьюетксов и семафоров - одно из условий задачи.

Добавлено через 10 минут

Сообщение от Убежденный

Вот здесь

C++
1
2
3
WaitForSingleObject(mutC, INFINITE);
Matrix::CalculateA(serial, P, A, B, C, MOMK[0]);
ReleaseMutex(mutC);

наблюдается противоположная картина: мьютекс захватывается
на время выполнения CalculateA. Чем дольше CalculateA, тем
длиннее ожидание других потоков на этом мьютексе.
А где же параллельность тогда ?

Добавил мьютекс только чтобы препод не приколупался на тему не защищенности ресурса.
Хотя по сути вектор С остальные потоки скопировали для себя еще до вычисления произведения МОМК, которое идет перед вычислением финального вектора А. Ждать его чисто физически никто не будет.

Добавлено через 8 часов 36 минут
Нашел ошибку. Была в схожем фрагменте, но уже там другим потокам приходилось ждать вычислений. Вопрос закрыт.

C++
1
2
3
WaitForSingleObject(mutMK, INFINITE);
Matrix::MatrixMatrix(serial, P, MOMK[0], MO[0], MK[0]);
ReleaseMutex(mutMK);

Новые блоги и статьи Все статьи Все блоги /
Символьное дифференцирование igorrr37 13.02.2026 / * Логарифм записывается как: (x-2)log(x^2+2) - означает логарифм (x^2+2) по основанию (x-2). Унарный минус обозначается как ! */ #include <iostream> #include <stack> #include <cctype>. . .	Камера Toupcam IUA500KMA Eddy_Em 12.02.2026 Т. к. у всяких "хикроботов" слишком уж мелкий пиксель, для подсмотра в ESPriF они вообще плохо годятся: уже 14 величину можно рассмотреть еле-еле лишь на экспозициях под 3 секунды (а то и больше),. . .	И ясному Солнцу zbw 12.02.2026 И ясному Солнцу, и светлой Луне. В мире покоя нет и люди не могут жить в тишине. А жить им немного лет.	«Знание-Сила» zbw 12.02.2026 «Знание-Сила» «Время-Деньги» «Деньги -Пуля»
SDL3 для Web (WebAssembly): Подключение Box2D v3, физика и отрисовка коллайдеров 8Observer8 12.02.2026 Содержание блога Box2D - это библиотека для 2D физики для анимаций и игр. С её помощью можно определять были ли коллизии между конкретными объектами и вызывать обработчики событий столкновения. . . .	SDL3 для Web (WebAssembly): Загрузка PNG с прозрачным фоном с помощью SDL_LoadPNG (без SDL3_image) 8Observer8 11.02.2026 Содержание блога Библиотека SDL3 содержит встроенные инструменты для базовой работы с изображениями - без использования библиотеки SDL3_image. Пошагово создадим проект для загрузки изображения. . .	SDL3 для Web (WebAssembly): Загрузка PNG с прозрачным фоном с помощью SDL3_image 8Observer8 10.02.2026 Содержание блога Библиотека SDL3_image содержит инструменты для расширенной работы с изображениями. Пошагово создадим проект для загрузки изображения формата PNG с альфа-каналом (с прозрачным. . .	Установка Qt-версии Lazarus IDE в Debian Trixie Xfce volvo 10.02.2026 В общем, достали меня глюки IDE Лазаруса, собранной с использованием набора виджетов Gtk2 (конкретно: если набирать текст в редакторе и вызвать подсказку через Ctrl+Space, то после закрытия окошка. . .

Загрузка ядер при паралельных вычислениях

Решение