Първо, нека да ви дам два цитата от членове на форума на други теми.
Ако не можете да програмирате на нещо различно от BASIC, и не знам как да паралелизация изчислителните процеси, това не означава, че другите не знаят и не знаят как. И ако правилно програмиран търсене, след това опциите са доста способни обичайната модерен personalke, и всичко това се прави за един много разумен период от време.
[Съобщението е адресирано до мен]
Сега моята програма не използва многоядрени, т.е. Можете да стартирате няколко програми за броя на процесорни ядра, работещи без увеличаване на времето.
Очевидно е, че и в двата цитата говорим за паралелен процес компютри в програмите, предназначени да се движат по многоядрени компютри.
Кой може да опитате?
Натали-Mak
Аз също имам малко познания.
Първото нещо, което ще кажа, са 3 нива на паралелното.
1) между компютрите
2) Между ядра
3) паралелизъм инструкция ниво.
За всяко ниво, да се използва своите инструменти.
1) между компютрите. Може би най-лесният начин да паралелна обработка на информацията. Да предположим, че имате компютър клас единна мрежа. Можете просто да копирате данните на компютъра и неговата програма и да изпълни. След получаване на резултата. Планирането на такава операция, където морето програми. Ако sroete клъстер онлайн. Тук все още трябва да се реши проблема на защита и системи за данни. А също и на факта, че компютрите в интернет е различна.
2) паралелността между ядрата. В много от компютър преработвателни предприятия са най-голямата е на централен процесор (CPU / CPU) и графичен процесор (GPU / GPU). Всеки процесор съдържа един или повече ядра. Ядрото може да се разглежда като отделно устройство, на която можете да стартирате вашата нишка. Обикновено не се споделя многопроцесорни и многоядрени.
За разлика от наличието на обща шина за достъп до обща памет.
Тук можем да се разграничат два вида SMP и Numa системи.
Симетрична мултипроцесорна (английски Симетрична мултипроцесорна, съкращение SMP.) - архитектурата на многопроцесорни компютри, които две и по-малко от две идентични процесори са свързани към обща памет. Когато влезете в споделена памет автобус е всичко блокиран на едновременното четене или писане не е възможно.
NUMA (Non-Uniform Memory Access - «нееднороден достъп до паметта" или Non-Uniform Memory Architecture - «Архитектура с нееднородни памет".
Архитектура в която достъп до различни части на паметта има различна скорост. Това се дължи на умни разпределение на паметта при достъп до паметта е без блокиране и достъп до обща заключена.
Ако говорим за процесора. След това в продължение на parallelizing код обикновено решен код едновременно писане за едно ядро и създаване на множество потоци. Обикновено има код. Това се постига на нивото на езика.
CreatThead (врекламния);
Thead.Do (функция);
функция - подпрограма да бъде изпълнено в няколко теми.
Това е най-примитивните. Там са по-напреднали неща, като например OpenMP което улеснява писането.
Нищо сложно. Само трябва да бъдат обучени, за да се научат да мислят в паралел.
Но за да се грижи за достъп до паметта и ключалки трябва да програмист.
SE (GPU) мощен изчислително устройство. Модерен SE много по-продуктивни, отколкото процесора. Затова е интересно да се използва за изчисления. Още по-интересно да тече един и същи код, както на процесора и GPU. За тези цели и CUDA ATIStreem и сътр.
развитие CUDA NVIDIA и ATI развитие ATIStreem. Така че тече един и същ код на картите от различни производители е трудно. Тя трябва да бъде пренаписана. Но не съм наясно с последните новости.
3) паралелизъм инструкция ниво.
Съвременните процесори имат multiskalyarnuyu архитектура. Всяко ядро обикновено има няколко АЛУ (аритметично логическо устройство). В определен организиране на данни и команди ядро може едновременно да изпълнява няколко команди. Все още има такова нещо като SIMD.
SIMD (инж една инструкция, множество данни -. Екип, много данни, SIMD) - на принципа на изчислителна техника, която позволява осигуряване на паралелизъм на ниво данни. Когато данните се групират по двойки, четири крака, осмици. И един отбор изпълнява една операция по колоездене данни ALU 2,4,8.
Какво може да се увеличи по време на работа няколко пъти (малко под две процесорни ядра)?
Да, можете. Налице е добре известен закон формула Amdahl, ако процентът на разходите е малък, можете да получите голям тласък. Тъй като процесора обикновено съдържа 2-4 ядки, но всеки ядро 8.16. ALU. Процесорът графики има десетки, стотици, хиляди отгоре ALU. Графичният процесор ALU обикновено конвенционално групирани в 4 8-малко ядра.
Ако знаете, Pascal. И щях да пиша по картофите Pascal / Delphi.
Уви! Сега аз не знам. Преди много време, когато работех, Pascal знаеше и пише на него програмата.
Сега, след много години, знам само основните (вж. Първата цитата)
Аз пиша в QBasic. Колега SVB установено, че има много добър компилатор PB5 (преди работа с преводача).
Написано от съставител десетки различни програми за изграждане на магически квадрати, нищо площади нормално построен
// Използва Типове данни
конст х = 43;
тип
PNumbers = ^ TNumbers;
TNumbers = масив [0..mx * х-1] на int64;
TMatrix = масив [0..mx-1, 0..mx-1] на int64;
тип
TAInteger = масив от цяло число;
процедура ViewSquare # 40; к: цяло число; MS: TMatrix; S: int64; р: булева = фалшива; A: Булева = фалшива # 41 ;; претоварване;
процедура ViewSquare # 40; Var F: текстов файл; к: цяло число; MS: TMatrix; S: int64; р: булева = фалшива; A: Булева = фалшива # 41 ;; претоварване;
Процедура ViewNumbers # 40; к: цяло число; S: int64; A: TNumbers # 41 ;;
процедура ViewMatrix # 40; к: цяло число; A: TNumbers # 41 ;;
функция GetCnk # 40 п, к: число # 41 ;: int64;
процедура Seta # 40; Var A: TNumbers; б: масив от int64 # 41 ;;
процедура SetM # 40; п: цяло число; Var М: TMatrix; б: масив от int64 # 41 ;; претоварване;
процедура SetM # 40; п: цяло число; Var М: TMatrix; б: масив от число # 41 ;; претоварване;
функция toMatrix # 40; п: цяло число; A: TNumbers # 41 ;: TMatrix;
функционални CheckMS # 40; п: цяло число; m: TMatrix; Var S: int64; Var р, а: булева # 41 ;: булева;
процедура ToMatrixRosser # 40; п: цяло число; A: TNumbers; Var М: TMatrix # 41 ;;
функция isMagic # 40; п: цяло число; М: TMatrix; Var S: int64; Var р: булева # 41 ;: булева;
функция isPMagic # 40; п: цяло число; М: TMatrix; S: int64 # 41 ;: булева;
процедура RosserToMatrix # 40; п: цяло число; М: TMatrix; Var A: TNumbers # 41 ;;
функция isDifferent # 40; п: цяло число; М: TMatrix # 41 ;: булева;
процедура SetAInteger # 40; а: масив от цяло число; VAR ли: TAInteger # 41 ;;
процедура Seta # 40; Var A: TNumbers; б: масив от int64 # 41 ;;
Var I: цяло число;
започвам
fillchar # 40 А, sizeof # 40 А # 41 # 41 0;, ;;
за I: = ниско # 40; б # 41; за високо # 40; б # 41; започвайте
А [Ь]: = б [Ь];
приключи;
приключи;
процедура ViewSquare # 40; к: цяло число; MS: TMatrix; S: int64; р: булева = фалшива; A: Булева = фалшива # 41 ;;
Вар, Й. цяло число;
започвам
напиши # 40; к ": [ '# 41 ;;
ако р а след това напишете # 40; 'р' # 41 ;;
ако след това да напишете # 40; "а" # 41 ;;
напиши # 40; ']:', S, ':' # 41 ;;
защото: = 0 до К-1 направи
за к: = 0 до К-1 се започне
напиши # 40; MS [I, J] # 41 ;;
ако # 40; и
writeln;
приключи;
процедура ViewSquare # 40; Var F: текстов файл; к: цяло число; MS: TMatrix; S: int64; р: булева = фалшива; A: Булева = фалшива # 41 ;;
Вар, Й. цяло число;
започвам
напиши # 40; F, к ": [ '# 41 ;;
ако р а след това напишете # 40; F, 'р' # 41 ;;
ако след това да напишете # 40; F, "а" # 41 ;;
напиши # 40; F, ']: "S,": "# 41 ;;
защото: = 0 до К-1 направи
за к: = 0 до К-1 се започне
напиши # 40; F, MS [I, J] # 41 ;;
ако # 40; и
writeln # 40; F # 41 ;;
приключи;
Процедура ViewNumbers # 40; к: цяло число; S: int64; A: TNumbers # 41 ;;
Var аз. цяло число;
започвам
напиши # 40; к, ':' # 41 ;;
напиши # 40; S, ':' # 41 ;;
защото: = 0 до К-1 се започне
напиши # 40 А [Ь] # 41 ;;
ако # 40; и
writeln;
приключи;
// Връща броя на комбинациите от п към к
// # 40; с изключение на реда на # 41;
// CNK = п / # 40 ;! К * # 40 ;! N-к # 41; # 41!;
функция GetCnk # 40 п, к: число # 41 ;: int64;
Var г: цяло число;
започвам
г: = п-к;
резултат: = 1;
а п> г се започне
резултат: = водят * п;
декември # 40; п # 41 ;;
приключи;
а к> 1 започвайте
Резултати: = водят DIV к;
декември # 40; к # 41 ;;
приключи;
приключи;
функция toMatrix # 40; п: цяло число; A: TNumbers # 41 ;: TMatrix;
Var, Й: цяло число;
започвам
fillchar # 40; резултат sizeof # 40; доведе # 41 0 # 41;, ;;
защото: = 0 до п-1 направи започва
за к: = 0 до п-1 направи започва
резултат [Ь, й]: = A [I * п + й];
приключи;
приключи;
приключи;
// MS Тест
функционални CheckMS # 40; п: цяло число; m: TMatrix; Var S: int64; Var р, а: булева # 41 ;: булева;
Вар, Й, L1, L2. цяло число;
S1: цяло число;
K: int64;
започвам
р: = фалшива;
резултат: = вярно;
// граф постоянна
S: = 0;
за к: = 0 до п-1 направи S: = S + m [0, й];
// Проверка на редовете
защото: = 0 до п-1 направи започва
S1: = 0;
за к: = 0 до п-1 направи S1: = S1 + m [Ь, й];
ако S1 <> S след това да започне
резултат: = фалшива;
изход;
приключи;
приключи;
// Проверка на колоните
защото: = 0 до п-1 направи започва
S1: = 0;
за к: = 0 до п-1 направи S1: = S1 + m [J, I];
ако S1 <> S след това да започне
резултат: = фалшива;
изход;
приключи;
приключи;
// Проверете дали двата диагонала
S1: = 0;
за к: = 0 до п-1 направи S1: = S1 + m [й, й];
ако S1 <> S след това да започне
резултат: = фалшива;
изход;
приключи;
S1: = 0;
за к: = 0 до п-1 направи S1: = S1 + m [й, п-1-й];
ако S1 <> S след това да започне
резултат: = фалшива;
изход;
приключи;
// Проверка pandiagonalnosti
р: = вярно;
за к: = 1 до п-1 направи започва
S1: = 0;
защото: = 0 до п-1 направи S1: = S1 + m [Ь, # 40; J + и # 41; мод п];
ако S1 <> S след това да започне
р: = фалшива;
прекъсване;
приключи;
приключи;
ако р след това да започне
за к: = N 2 * п-1 се започне
S1: = 0;
защото: = 0 до п-1 направи S1: = S1 + m [Ь, # 40; J-и # 41; мод п];
ако S1 <> S след това да започне
р: = фалшива;
прекъсване;
приключи;
приключи;
приключи;
// Проверка асоциативност
К: = М [0,0] + m [п-1, п-1];
а: = вярно;
L1: = # 40 п-1 # 41; Разделение 2;
защото: = 0 до l1 започвайте
L2: = # 40 п-1 # 41; Разделение 2;
ако п Mod 2 <> 0, тогава декември # 40; L2 # 41 ;;
за к: = 0 до L2 да започнат
S1: = М [Ь, й] + m [N-1-и, п-1-й];
ако S1 <> тогава K започне
а: = фалшива;
прекъсване;
приключи;
приключи;
приключи;
приключи;
функция isMagic # 40; п: цяло число; М: TMatrix; Var S: int64; Var р: булева # 41 ;: булева;
Var, Й: цяло число;
S1: int64;
започвам
резултат: = фалшива;
// изчислява сумата
S: = 0;
защото: = 0 до п-1 направи S: = S + М [0, Ь];
// String Преглед
защото: = 0 до п-1 направи започва
S1: = 0;
за к: = 0 до п-1 направи започва
S1: = S1 + М [Ь, й];
приключи;
ако S1 <> S след излизане;
приключи;
// Проверка колона
защото: = 0 до п-1 направи започва
S1: = 0;
за к: = 0 до п-1 направи започва
S1: = S1 + М [J, I];
приключи;
ако S1 <> S след излизане;
приключи;
// Проверете дали двата диагонала
S1: = 0;
за к: = 0 до п-1 направи започва
S1: = S1 + М [й, й];
приключи;
ако S1 <> S след излизане;
S1: = 0;
за к: = 0 до п-1 направи започва
S1: = S1 + М [й, п-1-й];
приключи;
ако S1 <> S след излизане;
р: = isPMagic # 40; N, М, S # 41 ;;
приключи;
функция isPMagic # 40; п: цяло число; М: TMatrix; S: int64 # 41 ;: булева;
Var к, I: цяло число;
S1. int64;
започвам
резултат: = фалшива;
за к: = 0 до п-1 направи започва
S1: = 0;
защото: = 0 до п-1 направи започва
S1: = S1 + М [Ь, # 40; К + и # 41; мод п];
приключи;
ако S1 <> S след излизане;
приключи;
за к: = N 2 * п-1 се започне
S1: = 0;
защото: = 0 до п-1 направи започва
S1: = S1 + М [Ь, # 40 К-и # 41; мод п];
приключи;
ако S1 <> S след излизане;
приключи;
процедура ToMatrixRosser # 40; п: цяло число; A: TNumbers; Var М: TMatrix # 41 ;;
Var I, J, K, L. цяло число;
започвам
защото: = 0 до п-1 направи започва
за к: = 0 до п-1 направи започва
к: = 40 # 3 * I + 2 * й # 41; мод п;
л: = # 40 2 * I + J # 41; мод п;
процедура RosserToMatrix # 40; п: цяло число; М: TMatrix; Var A: TNumbers # 41 ;;
Var I, J, K, L. цяло число;
започвам
защото: = 0 до п-1 направи започва
за к: = 0 до п-1 направи започва
к: = 40 # 3 * I + 2 * й # 41; мод п;
л: = # 40 2 * I + J # 41; мод п;
процедура SetM # 40; п: цяло число; Var М: TMatrix; б: масив от int64 # 41 ;;
Var, Й: цяло число;
започвам
защото: = 0 до п-1 направи
за к: = 0 до п-1 направи започва
М [Ь, й]: = б [I * п + й];
приключи;
приключи;
процедура SetM # 40; п: цяло число; Var М: TMatrix; б: масив от число # 41 ;;
Var, Й: цяло число;
започвам
защото: = 0 до п-1 направи
за к: = 0 до п-1 направи започва
М [Ь, й]: = б [I * п + й];
приключи;
приключи;
процедура ViewMatrix # 40; к: цяло число; A: TNumbers # 41 ;;
Var, Й: цяло число;
започвам
защото: = 0 до К-1 се започне
за к: = 0 до К-1 се започне
напиши # 40 А [I * K + J] "," # 41 ;;
приключи;
writeln;
приключи;
приключи;
// Проверете всички числа на матрицата
// връща истина, ако всички числа са различни
функция isDifferent # 40; п: цяло число; М: TMatrix # 41 ;: булева;
Var I, J, K, L, C: цяло число;
D: int64;
започвам
резултат: = вярно;
защото: = 0 до п-1 направи започва
за к: = 0 до п-1 направи започва
D: = М [I, J]; C: = 0;
за к: = 0 до п-1 направи започва
за л: = 0 до п-1 направи започва
ако m [К, L] = D след това започва
INC # 40 С # 41 ;;
ако в> 1 и след това започва
writeln # 40; D # 41 ;;
резултат: = фалшива;
изход;
приключи;
приключи;
приключи;
приключи;
приключи;
приключи;
приключи;
// а -> LS
процедура SetAInteger # 40; а: масив от цяло число; VAR ли: TAInteger # 41 ;;
Var I: цяло число;
започвам
SetLength # 40; LS, високо # 40; на # 41; -ниска # 40; на # 41 + 1 # 41 ;;
защото: = 0 до дължина # 40; ли # 41; - 1 Направете LS [Ь]: = а [Ь];
приключи;
Тази програма не е активиран многоядрени процесори.
Въпросът е дали и колко трудно е да се влиза в тази програма паралелното целия процес компютри?
Имам, както вече е писано, само две ядра в процесора. Моят колега SVB четириядрен процесор. Един приятел от друг форум, осем ядра и е готов да съдейства за изпълнението на програмата, но готов за паралелизация кодът не може.
Или, може би, да се използват множество ядра, е необходимо да се напише нов код? Кодът, че е написана за едноядрен процесор не е необходимо, го превърне в многоядрен процесор е трудно или невъзможно (?)
Това е въпросът!