Форум программистов, компьютерный форум, киберфорум
Наши страницы
С++ для начинающих
Войти
Регистрация
Восстановить пароль
 
Fenlou
1 / 1 / 2
Регистрация: 11.03.2014
Сообщений: 480
1

ОС Windows инициировала точку останова

08.12.2016, 19:36. Просмотров 208. Ответов 2
Метки нет (Все метки)

Здравствуйте, помогите устранить ошибку при выполнении программы
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
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include <mpi.h>
int ProcNum = 0; // Number of available processes
int ProcRank = 0; // Rank of current process
int GridSize; // Size of virtual processor grid
int GridCoords[2]; // Coordinates of current processor in grid
MPI_Comm GridComm; // Grid communicator
MPI_Comm ColComm; // Column communicator
MPI_Comm RowComm; // Row communicator
/// Function for simple initialization of matrix elements
void DummyDataInitialization(double* pAMatrix, double* pBMatrix, int Size){
    int i, j; // Loop variables
    for (i = 0; i<Size; i++)
        for (j = 0; j<Size; j++) {
            pAMatrix[i*Size + j] = 1;
            pBMatrix[i*Size + j] = 1;
        }
}
// Function for random initialization of matrix elements
void RandomDataInitialization(double* pAMatrix, double* pBMatrix,
    int Size) {
    int i, j; // Loop variables
    srand(unsigned(clock()));
    for (i = 0; i<Size; i++)
        for (j = 0; j<Size; j++) {
            pAMatrix[i*Size + j] = rand() / double(1000);
            pBMatrix[i*Size + j] = rand() / double(1000);
        }
}
// Function for formatted matrix output
void PrintMatrix(double* pMatrix, int RowCount, int ColCount) {
    
        int i, j; // Loop variables
    for (i = 0; i<RowCount; i++) {
        for (j = 0; j<ColCount; j++)
            printf("%7.4f ", pMatrix[i*ColCount + j]);
        printf("\n");
    }
}
// Function for matrix multiplication
void SerialResultCalculation(double* pAMatrix, double* pBMatrix,
    double* pCMatrix, int Size) {
    int i, j, k; // Loop variables
    for (i = 0; i<Size; i++) {
        for (j = 0; j<Size; j++)
            for (k = 0; k<Size; k++)
                pCMatrix[i*Size + j] += pAMatrix[i*Size + k] * pBMatrix[k*Size + j];
    }
}
// Function for block multiplication
void BlockMultiplication(double* pAblock, double* pBblock,
    double* pCblock, int Size) {
    SerialResultCalculation(pAblock, pBblock, pCblock, Size);
}
// Creation of two-dimensional grid communicator
// and communicators for each row and each column of the grid
void CreateGridCommunicators() {
    int DimSize[2]; // Number of processes in each dimension of the grid
    int Periodic[2]; // =1, if the grid dimension should be periodic
    int Subdims[2]; // =1, if the grid dimension should be fixed
    DimSize[0] = GridSize;
    DimSize[1] = GridSize;
    Periodic[0] = 0;
    Periodic[1] = 0;
    // Creation of the Cartesian communicator
    MPI_Cart_create(MPI_COMM_WORLD, 2, DimSize, Periodic, 1, &GridComm);
    // Determination of the cartesian coordinates for every process
    MPI_Cart_coords(GridComm, ProcRank, 2, GridCoords);
    // Creating communicators for rows
    Subdims[0] = 0; // Dimensionality fixing
    Subdims[1] = 1; // The presence of the given dimension in the subgrid
    MPI_Cart_sub(GridComm, Subdims, &RowComm);
    // Creating communicators for columns
    Subdims[0] = 1;
    Subdims[1] = 0;
    MPI_Cart_sub(GridComm, Subdims, &ColComm);
}
// Function for memory allocation and data initialization
void ProcessInitialization(double* &pAMatrix, double* &pBMatrix,
    double* &pCMatrix, double* &pAblock, double* &pBblock, double* &pCblock,
    double* &pTemporaryAblock, int &Size, int &BlockSize) {
    if (ProcRank == 0) {
        do {
            printf("\nEnter size of the initial objects: ");
            scanf("%d", &Size);
        
                if (Size%GridSize != 0) {
                    printf("Size of matricies must be divisible by the grid size!\n");
                }
        } while (Size%GridSize != 0);
    }
    MPI_Bcast(&Size, 1, MPI_INT, 0, MPI_COMM_WORLD);
    BlockSize = Size / GridSize;
    pAblock = new double[BlockSize*BlockSize];
    pBblock = new double[BlockSize*BlockSize];
    pCblock = new double[BlockSize*BlockSize];
    pTemporaryAblock = new double[BlockSize*BlockSize];
    for (int i = 0; i<BlockSize*BlockSize; i++) {
        pCblock[i] = 0;
    }
    if (ProcRank == 0) {
        pAMatrix = new double[Size*Size];
        pBMatrix = new double[Size*Size];
        pCMatrix = new double[Size*Size];
        DummyDataInitialization(pAMatrix, pBMatrix, Size);
        //RandomDataInitialization(pAMatrix, pBMatrix, Size);
    }
}
// Function for checkerboard matrix decomposition
void CheckerboardMatrixScatter(double* pMatrix, double* pMatrixBlock,
    int Size, int BlockSize) {
    double * MatrixRow = new double[BlockSize*Size];
    if (GridCoords[1] == 0) {
        MPI_Scatter(pMatrix, BlockSize*Size, MPI_DOUBLE, MatrixRow,
            BlockSize*Size, MPI_DOUBLE, 0, ColComm);
    }
    for (int i = 0; i<BlockSize; i++) {
        MPI_Scatter(&MatrixRow[i*Size], BlockSize, MPI_DOUBLE,
            &(pMatrixBlock[i*BlockSize]), BlockSize, MPI_DOUBLE, 0, RowComm);
    }
    delete[] MatrixRow;
}
// Data distribution among the processes
void DataDistribution(double* pAMatrix, double* pBMatrix, double*
    pMatrixAblock, double* pBblock, int Size, int BlockSize) {
    // Scatter the matrix among the processes of the first grid column
    CheckerboardMatrixScatter(pAMatrix, pMatrixAblock, Size, BlockSize);
    CheckerboardMatrixScatter(pBMatrix, pBblock, Size, BlockSize);
 
}
// Function for gathering the result matrix
void ResultCollection(double* pCMatrix, double* pCblock, int Size,
    int BlockSize) {
    double * pResultRow = new double[Size*BlockSize];
    for (int i = 0; i<BlockSize; i++) {
        MPI_Gather(&pCblock[i*BlockSize], BlockSize, MPI_DOUBLE,
            &pResultRow[i*Size], BlockSize, MPI_DOUBLE, 0, RowComm);
    }
    if (GridCoords[1] == 0) {
        MPI_Gather(pResultRow, BlockSize*Size, MPI_DOUBLE, pCMatrix,
            BlockSize*Size, MPI_DOUBLE, 0, ColComm);
            }
    delete[] pResultRow;
}
// Broadcasting matrix A blocks to process grid rows
void ABlockCommunication(int iter, double *pAblock, double* pMatrixAblock,
    int BlockSize) {
    // Defining the leading process of the process grid row
    int Pivot = (GridCoords[0] + iter) % GridSize;
    // Copying the transmitted block in a separate memory buffer
    if (GridCoords[1] == Pivot) {
        for (int i = 0; i<BlockSize*BlockSize; i++)
            pAblock[i] = pMatrixAblock[i];
    }
    // Block broadcasting
    MPI_Bcast(pAblock, BlockSize*BlockSize, MPI_DOUBLE, Pivot, RowComm);
}
// Cyclic shift of matrix B blocks in the process grid columns
void BblockCommunication(double *pBblock, int BlockSize) {
    MPI_Status Status;
    int NextProc = GridCoords[0] + 1;
    if (GridCoords[0] == GridSize - 1) NextProc = 0;
    int PrevProc = GridCoords[0] - 1;
    if (GridCoords[0] == 0) PrevProc = GridSize - 1;
    MPI_Sendrecv_replace(pBblock, BlockSize*BlockSize, MPI_DOUBLE,
        NextProc, 0, PrevProc, 0, ColComm, &Status);
}
void ParallelResultCalculation(double* pAblock, double* pMatrixAblock,
    double* pBblock, double* pCblock, int BlockSize) {
    for (int iter = 0; iter < GridSize; iter++) {
        // Sending blocks of matrix A to the process grid rows
        ABlockCommunication(iter, pAblock, pMatrixAblock, BlockSize);
        // Block multiplication
        BlockMultiplication(pAblock, pBblock, pCblock, BlockSize);
        // Cyclic shift of blocks of matrix B in process grid columns
        BblockCommunication(pBblock, BlockSize);
    }
}
// Test printing of the matrix block
void TestBlocks(double* pBlock, int BlockSize, char str[]) {
    MPI_Barrier(MPI_COMM_WORLD);
    if (ProcRank == 0) {
        printf("%s \n", str);
    }
    for (int i = 0; i<ProcNum; i++) {
        if (ProcRank == i) {
            printf("ProcRank = %d \n", ProcRank);
            PrintMatrix(pBlock, BlockSize, BlockSize);
        }
        MPI_Barrier(MPI_COMM_WORLD);
    }
}
void TestResult(double* pAMatrix, double* pBMatrix, double* pCMatrix,
    int Size) {
    double* pSerialResult; // Result matrix of serial multiplication
            double Accuracy = 1.e-6; // Comparison accuracy
    int equal = 0; // =1, if the matrices are not equal
    int i; // Loop variable
    if (ProcRank == 0) {
        pSerialResult = new double[Size*Size];
        for (i = 0; i<Size*Size; i++) {
            pSerialResult[i] = 0;
        }
        BlockMultiplication(pAMatrix, pBMatrix, pSerialResult, Size);
        for (i = 0; i<Size*Size; i++) {
            if (fabs(pSerialResult[i] - pCMatrix[i]) >= Accuracy)
                equal = 1;
        }
        if (equal == 1)
            printf("The results of serial and parallel algorithms are NOT "
            "identical. Check your code.");
        else
            printf("The results of serial and parallel algorithms are "
            "identical.");
    }
}
// Function for computational process termination
void ProcessTermination(double* pAMatrix, double* pBMatrix,
    double* pCMatrix, double* pAblock, double* pBblock, double* pCblock,
    double* pMatrixAblock) {
    if (ProcRank == 0) {
        delete[] pAMatrix;
        delete[] pBMatrix;
        delete[] pCMatrix;
    }
    delete[] pAblock;
    delete[] pBblock;
    delete[] pCblock;
    delete[] pMatrixAblock;
}
void main(int argc, char* argv[]) {
    double* pAMatrix; // The first argument of matrix multiplication
    double* pBMatrix; // The second argument of matrix multiplication
    double* pCMatrix; // The result matrix
    int Size; // Size of matricies
    int BlockSize; // Sizes of matrix blocks on current process
    double *pAblock; // Initial block of matrix A on current process
    double *pBblock; // Initial block of matrix B on current process
    double *pCblock; // Block of result matrix C on current process
    double *pMatrixAblock;
    double Start, Finish, Duration;
    setvbuf(stdout, 0, _IONBF, 0);
    MPI_Init(&argc, &argv);
    MPI_Comm_size(MPI_COMM_WORLD, &ProcNum);
    MPI_Comm_rank(MPI_COMM_WORLD, &ProcRank);
    GridSize = sqrt((double)ProcNum);
    if (ProcNum != GridSize*GridSize) {
        if (ProcRank == 0) {
            printf("Number of processes must be a perfect square \n");
        }
    }
    else {
                    if (ProcRank == 0)
                printf("Parallel matrix multiplication program\n");
        // Creating the cartesian grid, row and column communcators
        CreateGridCommunicators();
        // Memory allocation and initialization of matrix elements
        ProcessInitialization(pAMatrix, pBMatrix, pCMatrix, pAblock, pBblock,
            pCblock, pMatrixAblock, Size, BlockSize);
        DataDistribution(pAMatrix, pBMatrix, pMatrixAblock, pBblock, Size,
            BlockSize);
        // Execution of Fox method
        ParallelResultCalculation(pAblock, pMatrixAblock, pBblock,
            pCblock, BlockSize);
        ResultCollection(pCMatrix, pCblock, Size, BlockSize);
        TestResult(pAMatrix, pBMatrix, pCMatrix, Size);
        // Process Termination
        ProcessTermination(pAMatrix, pBMatrix, pCMatrix, pAblock, pBblock,
            pCblock, pMatrixAblock);
        Start = MPI_Wtime();
        DataDistribution(pAMatrix, pBMatrix, pMatrixAblock, pBblock,
            Size, BlockSize);
        // Execution of the Fox method
        ParallelResultCalculation(pAblock, pMatrixAblock, pBblock, pCblock,
            BlockSize);
        ResultCollection(pCMatrix, pCblock, Size, BlockSize);
        Finish = MPI_Wtime();
        Duration = Finish - Start;
        TestResult(pAMatrix, pBMatrix, pCMatrix, Size);
        if (ProcRank == 0) {
            printf("\nTime of execution = %f\n\n", Duration);
        }
        ProcessTermination(pAMatrix, pBMatrix, pCMatrix, pAblock, pBblock,
            pCblock, pMatrixAblock);
    
    }
    MPI_Finalize();
}
0
Миниатюры
ОС Windows инициировала точку останова  
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
08.12.2016, 19:36
Ответы с готовыми решениями:

ОС Windows инициировала точку останова в программе
Писал программу для нахождения минимального пути из точки start(Х) в точку...

Ошибка компиляции:ОС Windows инициировала точку останова
Доброго времени суток! Обращаюсь с наверняка очень распространенной проблемой....

ОС Windows инициировала точку останова в kursach.exe
Доброго времени суток! Проблема распространенная конечно, но в этом...

Ошибка. ОС Windows инициировала точку останова в файле
Доброго всем времени суток. Есть задание : Найти самое большое слово в файле и...

Странная ошибка ОС Windows инициировала точку останова
Что могло вызвать такую ошибку ? При нажатии кнопки продолжить программа...

2
Nishen
468 / 293 / 156
Регистрация: 26.02.2015
Сообщений: 1,359
Завершенные тесты: 2
08.12.2016, 19:41 2
Fenlou, попробуй с помощью дебаггера найти, где именно ошибка возникает.

Добавлено через 1 минуту
Как пользоваться отладчиком (в Visual Studio)
1
Fenlou
1 / 1 / 2
Регистрация: 11.03.2014
Сообщений: 480
12.12.2016, 20:44  [ТС] 3
Цитата Сообщение от Nishen Посмотреть сообщение
попробуй с помощью дебаггера найти, где именно ошибка возникает.
вот тут
C++
1
2
3
4
 if (ProcRank == 0) {
            printf("\nTime of execution = %f\n\n", Duration);
            fflush(stdout);
        }
0
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
12.12.2016, 20:44

ОС Windows инициировала точку останова в stroki.exe
#include&lt;iostream&gt; #include&lt;conio.h&gt; #include&lt;string&gt; #include&lt;stdio.h&gt;...

Windows инициировала точку останова при очистке динамической памяти
Собственно код, для самообразования перебрасывал адреса динамического массива в...

Сортировка по возрастанию: ошибка "ОС Windows иницииализировала точку останова"
Не знаю, в чем проблема. Написал такую программу #include &lt;stdio.h&gt; int n;...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
3
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2018, vBulletin Solutions, Inc.
Рейтинг@Mail.ru