Последовательная программа, которая обращается ко всему массиву

Question

Я работаю над потоками, однако прежде чем использовать потоки, я должен написать 2 программы.

1. Настройте массив и напишите последовательную программу, которая обращается ко всему массиву и выполняет некоторую простую задачу по содержимому.
2. Измените программу так, чтобы она была последовательной, но обращается к массиву с помощью ряда вызовов функции. Каждый вызов этой функции обрабатывает несколько строк массива, как определено параметром, переданным функции.

У меня проблемы с пониманием вопросов, кажется, это так просто, но, похоже, я не могу об этом подумать. Я должен написать программы на основе вышеуказанных двух вопросов, прежде чем я начну создавать программу, которая позволит обрабатывать одну или несколько потоков. Каждый поток должен обращаться к другому набору строк массива.

Для первого вопроса, то код, который я написал до сих пор

#include <iostream> 
#include <stdio.h> 

int main() 
{ 
    int array [20][20]; 
    int i, j; 

    /* output each array element's value */ 
    for (i = 0; i < 20; i++) 
    { 
     for (j = 0; j < 20; j++) 
     { 
     printf("a[%d][%d] = %d\n", i,j, array[i][j]); 
     } 
    } 
    system ("PAUSE"); 
    return 0; 
} 

Я хочу знать, если выше программа представляет собой последовательную программу? Я запустил программу, и он обратился ко всему массиву и выполнил одну задачу, которая заключается в том, чтобы распечатать все данные в массивах.

Я исследовал on-line то, что это означает, последовательной программой, и я нашел, что это означает следующее утверждение: выполнить задачу перед задачей b, но не в одно и то же время. Это правильно?

Для второй части я сделал следующее:

#include <iostream> 
#include <stdio.h> 

void print_array(int array[20][20]); 

int main() 
{ 
    int array [20][20]; 
    int i, j; 

    print_array(array); 

    system ("PAUSE"); 
    return 0; 
} 

// Output data in an array 
void print_array(int array) 
{ 
    int i, j; 
    for (i = 0; i < 20; i++) 
    { 
     for (j = 0; j < 20; j++) 
     { 
     printf("a[%d][%d] = %d\n", i,j, array[i][j]); 
     } 
    } 
} 

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

EDIT: Я использовать 2D массивы, жаль, что не было ясно, выше

Answer 1

Я считаю, что если вы не создавать отдельные темы, в любом случае, то вы на самом деле написание последовательной программы. В вашем коде нет части, где вы переходите в новый поток, чтобы выполнить некоторую операцию, в то время как основной поток выполняет что-то еще.

Резюме: код выполняется в одном потоке - это последовательный

Вы должны передать массив не как целое, но как двойной указатель ->int array[][] или int** array

Answer 2

Для выполнения операций на массиве последовательно было бы начать на первом месте в массиве и приращением через массив выполнения операций, как вы идете

array[10] = {0,1,2,3,4,5,6,7,8,9} 
    iterate through array with some action such as adding +5 
    array [10] = {5,6....} 

чтобы сделать это многопоточный вам нужно иметь различные темы, работают на разных сегментах массива, таких как места 0-4,5-9 и выполнить действие, чтобы это можно было сделать за меньшее время. Если вы делаете это так, вам не нужно беспокоиться о мьютексах.

Так Thread один приращения через массив [10] {0,1,2,3}

резьбы два приращения через массив [10] {4,5,6,7}

Каждое приращение один и оба потока одновременно выполняются

Answer 3

Я не думаю, что вы идете в правильном направлении, но вы не за горами. Инструкции, которые запрашиваются, - это некоторые из предварительных шагов, необходимых для последовательной обработки массива и обеспечения параллельной работы. При написании параллельной программы часто бывает полезно начать с рабочей последовательной программы и медленно преобразовать ее в параллельную программу. Следуя инструкциям, это способ сделать это.

Рассмотрим части вопроса отдельно:

• Настройка массива и написать последовательную программу, которая обращается весь массив и выполняет некоторые простые задачи по содержанию.

Простая задача, которую вы выбрали для своего массива, - это распечатать содержимое, но это не подходящая задача, потому что она не имеет функционального результата. Более подходящей задачей будет сумма элементов в массиве. Другими задачами могут быть подсчет элементов, которые удовлетворяют некоторому условию, или для нескольких элементов на два.

Итак, сначала попробуйте изменить исходную программу, чтобы суммировать элементы, а не печатать их.

(В коде используется двумерный массив. Я предложил бы использовать 1-мерный массив для простоты.)

• Измените программу так, чтобы она по-прежнему последовательная, но доступ к массив, серия вызовов функции. Каждый вызов этой функции обрабатывает несколько строк массива, как определено параметром, переданным функции.

В этой части вы пытаетесь разбить функциональность на небольшие части работы. (В конце концов вы отправите эти единицы работы в потоки для обработки, но сейчас делаете предварительные шаги.) Если бы мы сделали сумму в части 1, тогда здесь вы можете написать функцию, которая равна int sumKitems(int *array, int startIndex, int numItems). Затем основная программа будет вызывать это на каждом наборе (скажем) 10 элементов в массиве и комбинировать полные результаты, суммируя результаты каждого вызова sumKitems.

Итак, если в массиве имеется 100 элементов, вы можете сделать 10 звонков на номер sumKitems(...), сообщив функции для обработки 0 ... 9, 10 ... 19, ..., 90 ... 99. Это было бы вместо того, чтобы делать сумму по всем 100 предметам индивидуально.

-

Резюмируя, часть из них будет простой цикл, не слишком отличается от того, что вы написали, только с некоторыми вычисления выполняются.

Вторая часть должна выполнять точно такое же вычисление и возвращать точно такой же результат, просто используя другой вызов функции, который обрабатывает k элементов в момент времени. (Если вы передадите количество элементов, обрабатываемых одновременно, в качестве параметра, вы сможете сбалансировать стоимость связи и работу, выполняемую при переходе к потоковой реализации.)

В конце вам, вероятно, будет предложено заменить вызов на sumKitems(...) очередью, которая отправляет работу в потоки независимо.