72131683 tinh toan song song

HỌC VIỆN CÔNG NGHỆ BƯU CHÍNH VIỄN THÔNG

TÍNH TOÁN SONG SONG

(Dùng cho sinh viên hệ đào tạo đại học từ xa)

Lưu hành nội bộ

HÀ NỘI - 2007

HỌC VIỆN CÔNG NGHỆ BƯU CHÍNH VIỄN THÔNG


Biên soạn : THS. PHẠM VĂN CƯỜNG

Bài giàng


Biên soạn: Phạm Văn Cường

Khoa CNTT1- Học viện Công nghệ BCVT

Email: [email protected]

Mục lục

CHƯƠNG 1 : CÁC KIẾN TRÚC SONG SONG.........................................................................51.1 Tổng quan về tính toán song song ......................................................................................5

1.1.1 Nhu cầu tính toán............................................................................................................51.1.2 Lịch sử phát triển ............................................................................................................71.1.3 Các thuật ngữ ..................................................................................................................91.1.4 Các xu thế xây dựng máy tính ........................................................................................9

1.2 Các kiến trúc song song .....................................................................................................101.2.1 Máy tính một dòng lệnh, một dòng dữ liệu (SISD) ......................................................111.2.2 Bộ nhớ chia xẻ (shared memory) và bộ nhớ phân tán (distributed memory). .............131.2.3 Máy tính một dòng lệnh, nhiểu dòng dữ liệu (SIMD) ..................................................141.2.4 Máy tính nhiều dòng lệnh, một dòng dữ liệu (MISD) ..................................................171.2.5 Máy tính nhiều dòng lệnh, nhiểu dòng dữ liệu (MIMD) ..............................................191.2.6 Hiệu suất của Máy tính song song................................................................................20

1.3 Tổ chức các bộ vi xử lý ......................................................................................................211.3.1 Mạng hình lưới (Mesh).................................................................................................211.3.2 Mạng hình cây nhị phân (Binary Tree Networks) ........................................................221.3.3 Mạng hình siêu cây (Hypertree networks)....................................................................221.3.4 Mạng hình tháp (Pyramid networks) ............................................................................231.3.5 Mạng hình bướm (Butterfly networks).........................................................................241.3.6 Mạng hình siêu khối (Hypercube networks)................................................................251.3.7 Mạng các chu trình hướng kết nối khối (Cube-Connected Cycles networks) .............261.3.8 Mạng hoán vị di chuyển (Shuffle-exchange networks) ...............................................271.3.9 Mạng de Bruijn.............................................................................................................291.3.10 Tổng kết về tổ chức các bộ vi xử lý............................................................................29

1.4 Các hệ thống mảng bộ xử lý, đa bộ xử lý, và đa máy tính..............................................301.4.1 Hệ thống mảng bộ vi xử lý (processor arrays)..............................................................301.4.2 Máy tính đa bộ xử lý (Multiprocessors) .......................................................................351.4.3 Hệ thống đa máy tính (Multicomputers) ......................................................................39

1.5 Kết chương..........................................................................................................................411.6 Câu hỏi và bài tập ..............................................................................................................42

1.6.1 Câu hỏi..........................................................................................................................421.6.2 Bài tập...........................................................................................................................44

CHƯƠNG 2 : CÁC THUẬT TOÁN SONG SONG ..................................................................452.1 Mô hình PRAM .................................................................................................................45

2.1.1 Mô hình xử lý tuần tự ...................................................................................................462.1.2 Mô hình tính toán song song PRAM ............................................................................462.1.3 Một số thuật toán PRAM..............................................................................................48

2.2 Các thuật toán song song nhân hai ma trận ...................................................................562.2.1 Thuật toán nhân ma trận tuần tự ...................................................................................57

2.2.2 Thuật toán nhân ma trận trên máy SIMD với các bộ xử lý được tổ chức theo mạng hình lưới hai chiều (2-D Mesh SIMD). .................................................................................57

2.2.3 Thuật toán nhân ma trận trên máy SIMD với các bộ xử lý được tổ chức theo mạng hình siêu khối (Hypercube SIMD). .......................................................................................612.2.4 Thuật toán nhân ma trận trên máy đa bộ xử lý. ............................................................64

2.3 Các thuật toán sắp xếp song song. .............................................................................67

2.3.1 Sắp xếp bằng liệt kê (enumeration sort) và cận dưới (lower bounds) của sắp xếp song song........................................................................................................................................672.3.2 Sắp xếp song song đổi chỗ chẵn lẻ (odd-even transposition) . .....................................692.3.3 Sắp xếp song song trộn bitonic (bitonic merge) ...........................................................712.3.4 Sắp xếp song song tựa trên Quicksort ..........................................................................83

2.4 Thuật toán tìm kiếm song song trên danh bạ ...........................................................882.4.1 Độ phức tạp của tìm kiếm song song. ..................................................................882.4.2 Tìm kiếm song song trên máy tính đa bộ xử lý. ...................................................89

2.5 Thuật toán song song trên đồ thị ...............................................................................972.5.1 Thuật toán song song tìm đường đi ngắn nhất .....................................................972.5.2 Thuật toán song song tìm cây khung bé nhất .....................................................102

2.7 Kết chương ................................................................................................................1072.8 Câu hỏi và bài tập .....................................................................................................108

2.8.1 Câu hỏi........................................................................................................................1082.8.2 Bài tập.........................................................................................................................109

Lới nói đầu (chưa viết)

Chương 2: Các vấn đề của hệ thống tính toán song song LT8/BT2

2.1 Hiệu suất của hệ thống xử lý song song.

2.2 Tốc độ (speedup) và hiệu quả (efficiency) của xử lý song song

2.2.1 Tốc độ (speedup) của xử lý song song

2.2.2 Hiệu quả (efficiency) của xử lý song song

2.2.3 Định luật Amdhal và Gustafson-Barsis về tốc độ và hiệu quả của xử lý song song.

2.3 Ánh xạ dữ liệu trên máy tính song song

2.3.1 Ánh xạ dữ liệu lên các mảng bộ vi xử lý (processor arrays).

2.3.2 Ánh xạ dữ liệu lên hệ thống nhiều máy tính (multicomputers).

2.4 Vấn đề cân bằng tải động trên hệ thống nhiều máy tính (multicomputers)

2.5 Vấn đề lập lịch biểu trên hệ thống nhiều máy tính (multicomputers)

2.5.1 Giải thuật Graham ‘s List Scheduling

2.5.2 Giải thuật Coffman-Graham Scheduling

2.5.3 Các mô hình đơn định và không đơn định.

2.6 Vấn đề deadlocks

Chương 3: Lập trình song song LT9/TH4/KT1

3.1 Cơ bản về giao tiếp bằng phương pháp trao đổi thông điệp (message passing)

3.1.1 Trao đổi thông điệp như một mô hình lập trình

3.1.2 Cơ chế trao đổi thông điệp

3.1.3 Tiếp cận đến một ngôn ngữ cho lập trình song song

3.2 Thư viện giao diện trao đổi thông điệp (Message Passing Interface – MPI)

3.2.1 Giới thiệu về MPI

3.2.2 Lập trình song song bằng ngôn ngữ C và thư viện MPI

3.2.3 Một số kỹ thuật truyền thông: broadcast, scatter, gather, blocking message passing...

3.3 Máy ảo song song (Parallel Virtual Machine-PVM)

4.4 Thiết kế và xây dựng một chương trình (giải một bài toán (NP-complete) sử dụng MPI và C.

Thực hành: Xây dựng và chạy chương trình sử dụng C và MPI

CHƯƠNG 1 : CÁC KIẾN TRÚC SONG SONGNội dung chương này trình bày các vấn đề sau:- Tổng quan về tính toán song song: phần này trình bày về nhu cầu tính toán trên mọi lĩnh vực:

thương mại, khoa học…; lịch sử phát triển của máy tính song song, các xu thế thiết kế máy tính.- Các kiến trúc song song: phần này trình bày về 4 loại kiến trúc máy tính được phân loại theo thuật ngữ Flynn; máy tính một dòng lệnh, một dòng dữ liệu (SISD), máy tính một dòng lệnh, nhiều dòng dữ liệu (SIMD), máy tính nhiều dòng lệnh, một dòng dữ liệu (MISD) và máy tính nhiều dòng lệnh, nhiều dòng dữ liệu (MIMD).- Tổ chức các bộ vi xử lý trong các máy tính song song theo 9 cách khác nhau, bao gồm: tổ chức các bộ vi xử lý theo hình mạng lưới, theo hình cây, theo hình siêu cây, hình tháp, hình siêu khối, các chu trình hướng khối, hoán vị- đổi chỗ, và de Bruijn. Mỗi cách thức tổ chức được đánh giá ưu điểm, nhược điểm qua các tiêu chí: đường kích, độ rộng phân đôi và số nút/cạnh.- Một số máy tính song song thực tế: máy tính mảng các bộ vi xử lý, máy tính đa bộ xử lý và hệ thống đa máy tính. - Phần cuối cùng là câu hỏi và bài tập dành cho sinh viên.

1.1 Tổng quan về tính toán song song

1.1.1 Nhu cầu tính toán

Khoa học kinh điển dựa vào các quan sát, phát triển thành các lý thuyết và tiến hành thực nghiệm. Sự quan sát một hiện tượng một hiện tượng dẫn đến một giả thuyết nào đó. Nhà khoa học sẽ phát triển một lý thuyết để giải thích hiện tượng đó và thiết kế các thực nghiệm để chứng minh (hoặc bác bỏ) lý thuyết đó. Các kết quả từ thực nghiệm sẽ giúp các nhà khoa học hoàn chỉnh lý thuyết của mình. Một điều không may là không phải lúc nào ta cũng có thể sử dụng các thực nghiệm để kiểm chứng lý thuyết, đó là vì việc tiến hành các thục nghiệm đó tốn quá nhiều thời gian và tiền của. Các máy tính tốc độ cao sẽ cho phép các nhà khoa học kiểm chứng các giả thuyết của họ theo phương pháp mô phỏng các hiện tượng (numerical simulation). Nhà khoa học so sánh các kết quả của chương trình mô phỏng lý thuyết và quan sát các hiện tượng trong “thế giới thực” bằngchương trình mô phỏng. Các nhà khoa học sẽ hiệu chỉnh lý thuyết hoặc tiêp tục quan sát nếu có sự khác biệt.Chính vì vậy, khoa học hiện đại được mô tả bằng sự quan sát, lý thuyết, thực nghiệm và mô phỏng. Trong đó, mô phỏng ngày càng đóng vai trò quan trọng đối với các nhà khoa học. Nhiều bài toán khoa học phức tạp khi được mô phỏng yêu cầu độ phức tạp là hàm số mũ. A. a.Nhu cầu tính toán cho các ứng dụng khoa học.Các ứng dụng mới ngày càng có nhu cầu tiêu tốn tài nguyên phần cứng hơn.

Hình 1.1. Các ứng dụng mới ngày càng yêu cầu số lượng tính toán lớn

Điển hình là các loại ứng dụng :- Mô phỏng, mô hình hóa như các bài toán sau đây; những bài toán này vẫn còn là thách thức lớn (grand challenges) đối với khoa học, đó là:

1. Hóa học lượng tử (quantium), phương pháp thống kê, và vật lý tương đối.2. Vũ trụ (cosmology) và vật lý thiên văn (astrophysics).3. Động lực học (fluid dynamics)4. Thiết kế vật liệu và siêu dẫn5. Sinh học, dược học, so sánh DNA, công nghệ gen & protein…6. Y học và mô hình hóa sự hoạt động hệ xương và các cơ quan nội tạng7. Mô hình hóa khí hậu và sự biến đổi môi trường

Hình 1.2. Yêu cầu về phần cứng của các bài toán khoa học

Một ví dụ thực tế về mô hình hóa bài toán tính lưu lượng của dòng chảy đại dương [được thực hiện bởi các nhà khoa học từ đại học bang Oregon, Hoa kỳ]. Để đạt được kết quả chính xác, các nhà khoa học chia đại dương thành 4096 vùng từ đông sang tây và 1024 vùng từ bắc đến nam. Đồng thời, đại dương được chia thành 12 lớp; với mô hình này thì đại dương có khoảng 50 triệu

khối 3 chiều. Để mô phỏng cho một khối 3 chiều như vậy với một chu kỳ là 10 phút thì cần khoảng 30 tỉ phép tính. Trong khi đó các nhà nghiên cứu mô phỏng chu kỳ của đại dương trong vòng hàng trăm năm.

b.Nhu cầu tính toán cho các ứng dụng và dịch vụ thương mạiCác ứng dụng và dịch vụ thương mai ngày càng đa dạng, điển hình là: - Các ứng dụng đa phương tiện như: video servers, multimedia databases, video on demand…- Các ứng dụng về data mining và phân tích, xử lý dữ liệu trực tuyến (OLAP) - Các ứng dụng máy chủ thời gian thực, xử lý đồ họa… Đó là các dịch vụ yêu cầu khối lượng tính toán lớn:

Hình 1.3. Nhu cầu tính toán cho các ứng dụng thương mại

1.1.2 Lịch sử phát triển

Phải mất hơn 20 năm để các máy tính song song đi từ các phòng thí nghiệm ra thị trường. Daniel Slotnick tại đại học Illinois đã thiết kế hai máy tính song song sơm nhất đó là: Solomon được xây dựng bởi công ty Điện tử Westinghouse vào những năm 1960 và ILLIAC IV được lắp ráp bởi công ty Burroughs vào những năm 1970. Sau đó, trong suốt thập kỷ 70s, trường Đại học Carnegie Mellon xây dựng hai máy tính song song C.mmp và CM*. Vào năm 1980, các nhà khoa học tại Học viện kỹ thuật CalTech xây dựng máy tính Cosmic Cube, tiền thân của đa máy tính ngày nay và được hiện thực bới các công ty Ametek, Intel và nCUBE.Cho đến giữa thập kỷ 80, các máy tính song song với nhiều bộ vi xử lý mới được đưa ra thị trường. Một nghiên cứu về hiệu suất máy tính đối với các loại máy tính khác nhau đã chỉ ra lý do các máy tính song song dựa trên đa bộ xử lý trở thành hiện thực.

Trong hình 1.4, tỉ lệ gia tăng hiệu suất đối với các loại máy tính minicomputers, mainframes và supercomputers hàng năm chỉ dưới 20%. Trong khi đó, tỉ lệ gia tăng hiệu suất đối với các bộ xử lý (microprocessors) trung bình khoảng 35% mỗi năm.Tại sao hiệu suất của máy tính nhiều bộ vi xử lý tăng nhanh hơn các loại máy tính song song khác?. Hiệu suất của một bộ vi xử lý đơn có thể được cải tiến thông qua sự cải tiến kiến trúc hoặc cải tiến về công nghệ. Sự cải tiến về kiến trúc có thể làm tăng khối lượng công việc trông một chu kỳ lệnh. Sự cải tiến về công nghệ có thể làm giảm thời gian thực hiện chu kỳ lệnh. Những năm 1970s, các kiến trúc cơ bản: bộ nhớ có các bit song song (bit-parallel memory), bộ tính toán bit song song (bit-parallel arithmetic), bộ nhớ Cache, các kênh truyền dữ liệu, bộ nhớ xen kẽ (interleave memory), tiền xử lý lệnh (instruction lookahead), xử lý xen kẽ (pipelining), đa chức năng và các bộ trợ giúp xử lý xen kẽ dõng mã lệnh (pipelined functional unit)… đã được tích hợp vào thiết kế các siêu máy tính. Tuy nhiên, sự cải tiến hiệu suất của các bộ xử lý riêng lẻ (làm

1000

100

10

1

1965 1970 1975 1980 1985 1990

Supercomputers

Mainframes

Minicomputers

Microprocessors

Hình 1.4 : Hiệu suất của 4 loại máy tính song song thông dụng

giảm thời gian thực hiện chu kỳ lệnh) rất khó khăn vì điều này bị giới hạn bới tốc xử lý của vi mạch điện tử (bé hơn tốc độ ánh sang).Ngược lại, máy tính nhiều bộ vi xử lý đạt được các bước tiến về cải tiến hiệu suất rất ấn tượng. Mặc dù, ban đầu những máy tính nhiều bộ xử lý không kết hợp tất cả các cải tiến kiến trúc như trong các siêu máy tính và tốc độ đồng hồ của chúng khá chậm.

Sự hội tụ (convergence) giữa microcomputers và siêu máy tính truyền thống đã kéo theo sự thương mại hóa những máy tính song song với hàng trăm bộ xử lý. Đỉnh điểm là các máy tính song song dựa trên đa bộ vi xử lý có thể kể đến như: Intel ‘s Paragon XP/STM , MP-2TM, và Thinking Machine -5TM đã vượt qua tốc độ của các siêu máy tính đơn bộ xử lý như: Cray Y/MPTM và NEC SX -3TM .

1.1.3 Các thuật ngữ

Hầu hết các máy tính hiệu suất cao hiện đại đều hỗ trợ xử lý nhiều lệnh một cách đồng thời (concurrency). Chẳng hạn, đa xử lý (multiprocessing) là một phương pháp được sử dụng để đạt được xử lý đồng thời nhiều lệnh ở mức công việc hoặc chương trình. Trong khi đó, xử lý xen kẽ dòng lệnh (pipeline) là phương pháp nhằm xử lý đồng thời các lệnh ở mức lệnh (interinstruction). Tuy nhiên, không thể gọi các máy tính hỗ trợ xử lý các lệnh đồng thời là máy tính song song. Dưới đây là các thuật ngữ cơ bản:Lập trình song song (parallel programming) là việc lập trình sử dụng một ngôn ngữ có hỗ trợ xử lý song song các lệnh trong một chương trình.Máy tính song song (Parallel conputer) là một máy tính có nhiều bộ xử lý (multiple-processor computer) có khả năng phối hợp với nhau để giải quyết các bài toán.Xử lý song song (parallel computing) là quá trình sử dụng máy tính song song để giải quyết cácbài toán đơn (single problem) nhanh hơn. Siêu máy tính (supercomputer) là một máy tính đa năng có khả năng giải các bài toán đơn với tôc độ tính toán cao (cỡ hàng nghìn tỉ phép tính trong một giây). So với các máy tính được chế tạo cùng thời thì siêu máy tính có tốc độ xử lý lớn hơn hàng nghìn lần. Các siêu máy tính hiện đại là các máy tính song song. Một vài siêu máy tính có số lượng ít bộ xử lý nhưng rất mạnh; đa số siêu máy tính có số lướng bộ xử lý rất lớn.Thông lượng (throughput) của một thiết bị là lưu lượng dữ liệu được truyền tải qua thiết bị trong một đơn vị thời gian. Có nhiều cách để cải tiến thông lượng của một thiết bị như: tăng tốc độ, tăng số thao tác tại một thời điểm…Song song hóa dữ liệu (data parallelism) là việc sử dụng nhiều bộ chức năng (functional units) để xử lý cùng một thao tác đồng thời cho các phần tử của một tập dữ liệu.Tốc độ (speedup) là tỉ số giữa thời gian cần thiết xử lý một thuật toán tuần tự tốt nhất và thời gian cần thiết để xử lý pipeline hoặc song song trên cùng một máy tính.

1.1.4 Các xu thế xây dựng máy tính

a. Xu thế phát triển phần cứng:

- Hiệu suất bộ vi xử lý tăng 50 -100% mỗi năm.- Cứ 3 năm, số lượng các transitors tăng gấp đôi trên mỗi vi mạch.- Cứ 3 năm kích thước bộ nhớ RAM tăng 4 lần.

Hình 1.5 Xu thế phát triển phần cứng

b. Xu hướng thiết kế kiến trúc máy tính:- Giảm thời gian thực hiện chu kỳ lệnh máy; tuy nhiên, xu hướng này bị giới hạn bởi công nghệ điện tử.- Tăng số lệnh máy được thực hiện đồng thời (xử lý xen kẽ các dòng lệnh, siêu vô hướng ...)- Tăng số bít truyền dữ liệu song song 4 bít , 8 bít, 16 bít, 32 bít, 64 bít và 128 bít.- Song song ở mức luồng (multithread)- Nhiều bộ xử lý được tích hợp trên cùng một chip (dual core, quad. Core …).

1.2 Các kiến trúc song song

Kiến trúc của các máy tính song song có thể được chia làm hai loại (như hình dưới đây): kiến trúc đồng bộ, bao gồm: máy tính véc tơ, máy tính SIMD hoặc máy tính Systolic và kiến trúc không đồng bộ, bao gồm: máy tính MIMD, Reduction. Trong kiến trúc song song kiểu đồng bộ thì các bộ vi xử lý thực hiện đồng thời cùng một lệnh nào đó trên các bộ vi xử lý khác nhau (với dữ liệu có thể khác nhau) và kết thúc trong cùng một chu kỳ lệnh. Ngược lại, kiến trúc song song kiểu không đồng bộ thì các bộ vi xử lý có thể thực hiện các lệnh khác nhau, hoặc các đoạn chương trình khác nhau và có thể kết thúc việc xử lý lệnh trong các thời điểm khác nhau.

Hình 1.6. Hai loại kiến trúc song song: đồng bộ và không đồng bộ

1.2.1 Máy tính một dòng lệnh, một dòng dữ liệu (SISD)

a. Máy tính SISD

Hình trên là kiến trúc tổng quan của máy tính SISD (Single Instruction stream Single Data stream). Nó bao gồm hai đầu vào: dòng lệnh và dòng dữ liệu; một bộ điều khiển chứa bộ giải mã lệnh và bộ tạo xung điều khiển; và một bộ xử lý lệnh và dữ liệu. Các máy tính SISD là các máy tính xử lý tuần tự. Tại một thời điểm, chỉ một dòng lệnh và một dòng dữ liệu được xử lý. Chính vì vậy mà máy tính SISD còn được gọi là máy tính có von Neumann.Mặc dù dòng lệnh (instruction stream) được xử lý một cách tuần tự, nhưng các lệnh có thể được xử lý đồng thời theo có chế xen kẽ dòng mã lệnh (pipeline). Nhưng tại một thời điểm, chỉ có duy nhất một lệnh được giải mã (decode) hoặc được đọc (fetch). Máy tính SISD có thể có nhiều bộ chức năng (multiple functional units) như: bộ đồng xử lý toán học (mathematics co-processor), bộ vector (vector units), các bộ xử lý đồ họa (graphics processors), và các bộ xử lý vào/ra (I/O processors). Trong mô hình kiến trúc máy tính SISD, tất cả các bộ chức năng đều được điều khiển bởi một bộ xử lý (single processing unit) đơn.Một số biến thể của máy tính SISD như Systolic có thể tăng năng lực xử lý nhờ vào tích hợp nhiều bộ xử lý lệnh và dữ liệu như hình dưới đây:

Hình 1.7. Mô hình máy tính SISD cổ điển

Một số máy tính SISD hiện đại như Cray-1 còn hỗ trợ nhiều bộ xử lý kiểu vector (như hình trên). Dòng dữ liệu được “lọc” qua một mảng các bộ xử lý (processing units) để xử lý. Do đó, người ta còn gọi các máy tính SISD với mảng các bộ xử lý là máy tính Systolic.b. Ví dụ về thực hiện bài toán Banking trên máy tính song song Systolic:Số bộ vi xử lý = số máy ATMSố công việc = số khách hàngCó m khách hàng, thời gian phục vụ mỗi khách hàng là ti .Có n máy ATM,Với n=1: xử lý tuần tự; thời gian thực hiện sẽ là tổng thời gian phục vụ từng khách hàng: T= t1+ t2+ … tn Với m=n, trường hợp tốt nhất; thời gian thực hiện sẽ là T=max {t1, t2,…,tn} Với n<m, mục tiêu là xử lý công việc sao cho tại mỗi thời điểm, số máy ATM không làm việc là ít nhất. Trong trường hợp này máy tính Systolic giải bài toán trên như sau:

Hình 1.9. Giải bài toán Banking trên máy Systolic

Bước 1: đọc số tài khoảnBước 2: kiểm tra tính hợp lệ và số dư trong tài khoảnBước 3: cập nhật tài khoản với giao dịch mớiBước 4: nhận tiền từ khách hàng (deposit) hoặc trả tiền rút (withdraw) cho khách hàng.

Hình 1.8. Mô hình máy tính SISD với mảng bộ xử lý

Thời gian thực hiện: (1/n) *(t1+ t2+ … tn) ~ (t*m)/n.

c. Một số máy tính SISD thực tế :

CDC 6600 : không hỗ trợ xử lý pipeline, nhưng được tích hợp các bộ đa chức năng. CDC 7600: là thế hệ sau của CDC 6600, có bộ xử lý toán học và logic (ALU) có hỗ trợ

xử lý pipeline. Amdhal 470/6: hỗ trợ xử lý pipeline. Cray-1: hỗ trợ vector các bộ xử lý.

1.2.2 Bộ nhớ chia xẻ (shared memory) và bộ nhớ phân tán (distributed memory).

a. Khái niệm về chia xẻ phương tiện (shared medium).- Cho phép nhận một thông điệp tại một thời điểm.- Các thông điệp có thể truyền rộng rãi (broadcast).- Mỗi bộ xử lý “lắng nghe” (listens) các thông điệp chuyển đến.- Cơ chế trọng tài là tập trung.- Yêu cầu truyền lại thông điệp nếu có đụng độ.- Ethernet, Bus là các ví dụ điển hình về chia sẻ phương tiện.Các kiến trúc song song sẽ hỗ trợ truyền thông điệp kiểu điểm-điểm giữa các cặp bộ vi xử lý, các bộ xử lý được kết nối với nhau theo một hình trạng (topology) nào đó (star, ring..)Hai ưu điểm của chia sẻ phương tiện là có thể truyền đồng thời nhiều thông điệp (broadcast) tại một thời điểm và dễ dàng mở rộng (khi bổ sung thêm CPU).b. Bộ nhớ chia sẻ :

Hình 1.10. Bộ nhớ chia sẻ

- Mỗi bộ xử lý có thể thao tác trên nhiều dữ liệu khác nhau (thậm chí tất cả) trên bộ nhớ chia sẻ.

- Kết nối các bộ xử lý (qua bus, mạng…)- Có bộ nhớ chia sẻ toàn cục- Giao tiếp với bộ nhớ toàn cục thông qua READ/WRITE

c. Bộ nhớ phân tán :

Hình 1.11. Bộ nhớ phân tán

- Kết nối giữa các cặp CPU + bộ nhớ cục bộ- Giao tiếp qua thông điệp (message) được truyền qua mạng.- Dễ dàng mở rộng.

1.2.3 Máy tính một dòng lệnh, nhiểu dòng dữ liệu (SIMD)

Tất cả các bộ vi xử lý trên một máy SIMD thực hiện cùng một lệnh một cách đồng bộ trên các dữ liệu khác nhau.Trong một máy SIMD, nhiều thành phần xử lý được giám sát bởi một đơn vị điều khiển. Tất cả những thành phần xử lý đều nhận cùng mệnh lệnh từ đơn vị điều khiển nhưng lại thực hiện trên những tập dữ liệu khác nhau và đến từ những luồng dữ liệu khác nhau. Một máy SIMD biểu diễn ở hình 1.12 có những đặc điểm sau: xử lí phân tán trên một số lượng lớn phần cứng, thực hiện đồng thời trên nhiều thành phần dữ liệu khác nhau và thực hiện cùng một câu lệnh trên các thành phần dữ liệu.

Hình 1.12. Kiến trúc máy tính SIMD

Máy tính SIMD đóng vai trò quan trọng trong xử lý song song. Chúng có thể thao tác trên các dữ liệu biểu diễn dưới dạng vector hay ma trận; trên thực tế các dữ liệu về thời tiết hoặc các nghiên cứu về bức xạ gây ung thư thường được biểu diễn dưới dạng véc tơ. Máy SIMD có thể xử lý các bài toán này trong một khoảng thời gian ngắn hơn so với các mô hình khác. Trong trường hợp kích thước của vector đúng bằng số lượng bộ vi xử lý thì hiệu suất của máy SIMD sẽ đạt tối ưu. Trong trường hợp mà số bộ vi xử lý và kích thước vector khác nhau, thì tốc độ xử lý của máy tính SIMD cũng tốt hơn nhiều so với máy tính tuần tự.

Dưới đây ta tìm hiểu về 3 loại máy tính SIMD :a. Máy tính SIMD với bộ nhớ phân tán: SIMD với bộ nhớ phân tán gồm một bộ điều khiển (Control Unit) với nhiều bộ xử lý (Processing Elements). Các bộ xử lý hoạt động giống như các bộ tính toán số học (Arithmetic Unit). Các bộ tính toán số học là thợ (slaver) được điều khiển bởi bộ điều khiển là chủ (Master). Các bộ tính toán số học không thể tự đọc hoặc giả mã lệnh, chúng chỉ là các bộ tính toán thuần túy có thể thực hiện được các phép tính cộng, trừ, nhân, và chia. Mỗi bộ tính toán số học có thể truy cập tới bộ nhớ cục bộ của chúng. Trong trường hợp, bộ tính toán số học này cần thông tin chứa trong bộ tính toán số học khác, nó phải gửi yêu cầu đến bộ điều khiển và bộ điều khiển sẽ làm nhiêm vụ đọc thông tin của bộ tính toán số học đó và gửi đến bộ tính toán số học đã yêu cầu.

Hình 1.13 Máy tính SIMD với bộ nhớ phân tán

Ưu điểm của kiến trúc này là ta có thể rất dễ dàng mở rộng bộ nhớ toàn cục cũng như cục bộ trên mỗi bộ tính toán số học. Nhược điểm dể nhận thấy là mất nhiều thời gian khi bộ điều khiển phải quản lý tất cả các trao đổi thông tin giữa các bộ tính toán số học. Trong trường hợp phải thực hiện một chương trình mà có nhu cầu trao đổi dữ liệu lớn giữa các bộ xử lý thì thời gian chờ sẽ làm hạn chế hiệu suất của hệ thống tính toán.

b. Máy tính SIMD với bộ nhớ chia sẻ:Một kiến trúc khác của SIMD được thiết kế với sự kết hợp giữa các bộ xử lý (Processing Element) với các mô đun bộ nhớ. Trong kiến trúc này, bộ nhớ cục bộ của mỗi bộ tính toán số học ở trên được thay thế bằng các mô đun nhớ. Các mô đun nhớ này được chia sẻ cho tất cả các bộ xử lý thông qua mạng hoặc các thiết bị chuyển mạch. Điều này cho phép các bộ xử lý truy cập đến bộ nhớ chia sẻ mà không phải truy cập qua bộ điều khiển như ở trên; đây cũng là ưu điểm của kiến trúc này. Nhược điểm của kiến trúc này là khó khăn khi ta muốn mở rộng các mô đun nhớ vì bị giới hạn của không gian địa chỉ của máy tính.

c. Máy tính SIMD có sự hỗ trợ của pipelineKiến trúc SIMD có sự hỗ trợ của pipeline bao gồm một bộ tính toán số học có hỗ trợ pipeline với bộ nhớ chia xẻ. Xử lý pipeline có thể đọc các lệnh từ các dòng mã lệnh (instruction streams) khác nhau và thực hiện chúng trên cùng một bộ tính toán số học. Pipeline là một thủ tục xử lý theo kiểu vào trước ra trước (First In First Out) và hiệu xuất pipeline là tương đối. Để tăng hiệu quả của xử lý pipeline thì dữ liệu được lưu trong bộ nhớ chia xẻ để bộ xử lý có thể đọc chúng càng nhanh càng tốt. Ưu điểm có thể nhận thấy là tốc độ và hiệu quả của xử lý dữ liệu với yêu cầu trên được thỏa mãn..

d. Một số ví dụ Ví dụ 1: Bài toán banking

Bài toán banking (đã đề cập ở phần 1.2.1) thực hiện trên máy SIMD như sau:

Hình 1.14 Giải bài toán Banking trên Máy tính SIMD

Tất cả các bộ xử lý sẽ cùng thực hiện một lệnh (hoặc chờ) tại cùng một thời điểm trên các dữ liệu khác nhau.Bước 1: phân chia (partition) dữ liệu cho các bộ vi xử lý (máy ATM)Bước 2: thực hiện các giao dịch một cách song song.Hiệu suất phụ thuộc vào có bao nhiêu giao dịch được thực hiện song song.Giả sử khối lượng công việc được phân chia đều (balanced) thì:Gọi t là thời gian để phân phát dữ liệu và gửi trả về kết quả thì:Thời gian tốt nhất là: T= t+ max {t1, t2,…,tn}

Ví dụ 2: Bài toán quản lý nhân viênThông tin của mỗi nhân viên là một bản ghi, và có trường salary chứa thông tin về hệ số lương của từng nhân viên.Bước 1: Phân phát mỗi một bộ xử lý (PE) lưu trữ một bản ghi về nhân viên.Bước 2: Đoạn chương trình sau được thực hiện đồng thời:

If salary >100K thenSalary=salary * 1.05

ElseSalary=salary * 1.10

Toàn bộ lương của nhân viên được tính trong 1 bước. Sẽ có một số bộ xử lý được thực hiện, còn lại sẽ không được kích hoạt (disabled).

1.2.4 Máy tính nhiều dòng lệnh, một dòng dữ liệu (MISD)

MISD là một kiến trúc song song mà trong đó tại mỗi thời điểm các bộ xử lý thực hiện các thao tác khác nhau trên cùng một dữ liệu. Máy tính MISD có ý nghĩa về mặt lý thuyết nhiều hơn thực tế. Trên thực tế, chưa có máy tính MISD nào được thương mại hóa.

Máy tính MISD còn được gọi là máy tính với các mảng Systolic (Systolic arrays machine), chúng đóng vai trò đối với các bài toán “làm mịn” dữ liệu bằng cách “bơm” (pump) dữ liệu từ bộ xử lý này đến bộ xử lý khác. Mỗi bộ vi xử lý có thể thay đổi dữ dữ liệu trước khi chuyển dữ liệu sang bộ xử lý khác. Các thao tác thay đổi dữ liệu trên các bộ vi xử lý có thể khác nhau.

Hình 1.15. Kiến trúc MISD

IS : Instruction Stream – dòng lệnhDS: Data Stream – dòng dữ liệuCU : Control Unit – Bộ điều khiểnPU : Processing Unit – Bộ xử lý.

Hai ứng dụng trong thực tế mà máy tính MISD có thể nhắm tới là hệ thống hỗ trợ xử lý đa pipeline (hyper pipeline) và hệ thống dung thứ lỗi (fault tolerance).

Ví dụ minh họa: chương trình tìm max, min và medium của 3 số.

Hình 1.16. Một ví dụ thực hiện trên máy tính MISD

Với một dòng dữ liệu đầu vào gồm các số a,b và c. Dòng dữ liệu này đi qua máy tính MISD là được máy tính MISD thực hiện đồng thời 3 thao tác: tìm giá trị lớn nhất, bé nhất và trung bình của ba số trên.

1.2.5 Máy tính nhiều dòng lệnh, nhiểu dòng dữ liệu (MIMD)

Máy tính MIMD còn được gọi là máy tính đa bộ xử lý (multiprocessors) trong đó các bộ xử lý có các chức năng độc lập nhau. Tại bất cứ thời điểm nào, các bộ xử lý của máy tính MIMD có thể thực hiện các lệnh khác nhau trên các dữ liệu khác nhau một cách không đồng bộ. Máy tính MIMD đã và đang được ứng dụng rất rộng rãi trên nhiều lĩnh vực như: thiết kế và sản xuất có sự trợ giúp của máy tính (computer-aided design/ computer-aided manufacturing), mô phỏng, mô hình hóa, chuyển mạch … Các máy tính MIMD có thể có bộ nhớ chia xẻ hoặc phân tán tùy thuộc vào cách thực truy cập bộ nhớ của các bộ vi xử lý.Dưới đây là một số loại máy tính MIMD thông dụng.a. Máy tính MIMD với bộ nhớ chia sẻ

Hình 1.17. Kiến trúc máy tính MIMD

Máy tính MIMD với bộ nhớ chia sẻ bao gồm các bộ vi xử lý cùng chia sẻ một bộ nhớ toàn cục. Bộ nhớ toàn cục là một bộ nhớ được quản lý tập trung mà các bộ vi xử lý đều có thể truy cậpđược địa chỉ bất kỳ. Bộ nhớ toàn cục bao gồm nhiều mô đun nhớ. Máy tính MIMD với bộ nhớ chia sẻ có thể dễ dàng nâng cấp (scalability) để đáp ứng nhu cầu tính toán: dễ bổ sung các mô đun bộ nhớ và bộ vi xử lý. Việc quản lý trao đổi vào/ ra được thực hiện bởi các bộ điều khiển (Control unit) hoặc thiết bị vào ra (I/O devices).Trên thực tế có 3 loại máy tính MIMD với bộ nhớ chia sẻ:- Máy tính MIMD với bộ nhớ chia sẻ dựa trên bus (bus-based shared memory MIMD machines):Tất cả các bộ xử lý được kết nối với nhau thông qua một hệ thống Bus và hệ thống Bus này cũng được kết nối tới các bộ xử lý. Tùy theo thiết kể hoặc nhu cầu thực tế mà loại máy tính này có thểcó các loại bus khác nhau hoặc cho phép các bộ vi xử lý giao tiếp trực tiếp với nhau. Thông thường thì các loại bus này cũng được sử dụng để đồng bộ giữa các bộ xử lý. Máy tính MIMD dựa trên bus có nhược điểm là tại một thời điểm, không có nhiều bộ vi xử lý được hỗ trợ truy cập bộ nhớ vì khả năng tranh chấp đường truyền (contention) khi sử dụng bus để truy cập bộ nhớ toàn cục là rất lớn. Chúng phải tuân theo cơ chế trọng tài bus trong khi sử dụng các bus chung để truyền tải dữ liệu. Khi nhu cầu về trao đổi dữ liệu càng lớn, thì khả năng tranh chấp đường truyềnvà thời gian chờ giữa các bộ xử lý càng cao. Điều này làm ảnh hưởng đến hiệu suất chung của toàn hệ thống.

- Máy tính MIMD với bộ nhớ chia sẻ mở rộng (extended shared memory MIMD machines): Máy tính MIMD với bộ nhớ chia sẻ mở rộng được sinh ra để khắc phục tình trạng tranh chấp đường truyền khi sử dụng bus để truy cập bộ nhớ toàn cục. Bằng cách chia nhỏ bộ nhớ toàn cục thành các đơn vị bộ nhớ nhỏ hơn nhưng độc lập với nhau. Những đơn vị bộ nhớ này sẽ được kết nối với các bộ vi xử lý bằng một liên mạng (interconnection network). Các đơn vị bộ nhớ được xem như một bộ nhớ tập trung hợp nhất. Liên mạng được sử dụng trong kiến trúc này có thể là một mạng chuyển mạch chéo (crossbar switching network). Trong liên mạng này, nếu có N bộ vi xử lý được kết nối đến M đơn vị bộ nhớ và cần N*M chuyển mạch. Số chuyển mạch là khá lớn khi mở rộng kiến trúc; gây tốn kém về mặt kinh tế nếu phải kết nối một số lượng lớn bộ xử lý.

- Máy tính MIMD với bộ nhớ chia sẻ phân cấp (hierarchical shared memory MIMD machines):Máy tính MIMD với bộ nhớ chia sẻ phân cấp sử dụng một hệ thống bus phân cấp cho phép các bộ vi xử lý có thể truy cập bộ nhớ toàn cục. Các bus nội bộ được sử dụng để giao tiếp giữa các bộ vi xử lý trên cùng một bo mạch (board). Các bus ngoài cho phép các bộ vi xử lý nằm trên các bo mạch khác nhau có thể giao tiếp được với nhau. Với kiến trúc này máy tính có thể hỗ trợ mở rộng đến hàng ngàn bộ vi xử lý.

b. Máy tính MIMD với bộ nhớ phân tánTrong máy tính MIMD với bộ nhớ phân tán, mỗi bộ vi xử lý có riêng một bộ nhớ cục bộ. Các dữ liệu cần chia sẻ được truyền từ bộ xử lý này đến bộ xử lý khác như các thông điệp (message). Vì không có bộ nhớ chia sẻ nên việc tranh chấp đường truyền (contention) không còn là hạn chế đối với loại máy này. Tuy nhiên, mô hình này đòi hỏi chi phí cao trong trường hợp có nhiều bộ vi xử lý vì chúng được kết nối trực tiếp với nhau. Một cách để giảm bớt chi phí là hạn chế số lượng bộ xử lý kết nối trực tiếp: một bộ vi xử lý có thể kết nối với 1 số bộ vi xử lý khác thay vì kết nối với tất cả các bộ vi xử lý còn lại. Cách thiết kế này trên thực tế lại kém hiệu quả về thời gian yêu cầu để truyền thông điệp giữa hai bộ vi xử lý vì các thông điệp phải đi qua các bộ vi xử lý trung gian.Có hai cách tổ chức bộ vi xử lý thông dụng có thể giảm được thời gian truyền tải các thông điệp giữa các bộ vi xử lý đó là: tổ chức theo mạng hình siêu khối và hình lưới mà ta sẽ thảo luận ở các phần sau.

1.2.6 Hiệu suất của Máy tính song song

Hiệu suất (performance) là số lượng công việc được hoàn thành trong một đơn vị thời gian (work done per time unit).

Ví dụ: về tính hiệu suất của một máy tính SIMDTính tổng hai vector có kích thước 1024 A và B,Biết rằng : thời gian để thực hiện 1 phép cộng là 1 μs. Bước 1: bộ vi xử thứ i sẽ nhận các phần tử A[i] và B[i] với i= 1..1024.Bước 2: thực hiện cộng chúng một cách song song.Tính hiệu Suất trong 2 trường hợp :Trường hợp 1: Số bộ vi xử lý là 1024.P= (1024 phép tính) / (1 chu kỳ * 1 μs) = 1024 * 10 9 ops/ s

Trường hợp 2: Số bộ vi xử lý là 1000.P= (1024 phép tính) / (2 chu kỳ * 1 μs) = 512 * 10 9 ops/ sChỉ có 24 bộ xử lý thực hiện trong chu kỳ thứ 2, 1000 bộ xử lý khác idle. Điều kiện để một bộ vi xử lý có thể idle là do không có dữ liệu hoặc là do câu lệnh có điều kiện.

1.3 Tổ chức các bộ vi xử lý Trong phần náy ta sẽ thảo luận 9 mô hình tổ chức các bộ vi xử lý quan trọng của sự kết nối các bộ vi xử lý trong các máy tính song song. Một mô hình tổ chức các bộ vi xử lý có thể được biểu diễn bởi một đồ thị trong đó các đỉnh (vertices) hoặc nút (node) biểu diễn các bộ vi xử lý và các cạnh (edges) biểu diễn các đường truyền thông giữa các cặp bộ vi xử lý. Dưới đây là các tiêu chuẩn để đánh giá tính hiệu quả của các mô hình tổ chức các bộ vi xử lý đối với các thuật toán song song thực hiện trên phần cứng. Đường kính (diameter) : của một mạng các bộ vi xử lý là khoảng cách lớn nhất giữa hai nút.Đường kính càng nhỏ thì càng tốt vì đường kính là cận dưới của độ phức tạp về truyền thông của các thuật toán song song. Nó chỉ số bộ vi xử lý trung gian ít nhất mà thông điệp phải đi qua giữa hai bộ vi xử lý bất kỳ. Độ rộng phân đôi (Bisection width): của một mạng các bộ vi xử lý là số cạnh nhỏ nhất có thể bỏ đi để chia mạng thành hai nửa (hơn kém nhau không quá 1 nút). Độ rộng phân đôi càng lớn thì càng tốt bởi vì trong các thuật toán yêu cầu một lượng lớn dữ liệu được di chuyển thì kích thước của tập dữ liệu chia cho độ rộng phân đôi sẽ là cận dưới của độ phức tạp về truyền thông của một thuật toán song song.Số cạnh của một nút (number of edges per node): Trường hợp tốt nhất là số cạnh của một nút là một hằng số độc lập với kích thước của mạng; Bởi vì, nếu vậy ta sẽ dễ dàng mở rộng mạng với một số lượng nút lớn.

1.3.1 Mạng hình lưới (Mesh)

Trong một mạng hình lưới, các nút được sắp xếp trong một lưới q-chiều. Chỉ các nút lân cận có thể giao tiếp được với nhau vì vậy một nút trong có thể giao tiếp được với 2q nút.Một số biến thể của mạng hình lưới cho phép các kết nối vòng (wrap-around) giữa các bộ vi xử lý trên các cạnh của hình lưới. Các kết nối này có thể kết nối các bộ vi xử lý trên cùng một hàng hoặc cột hoặc các cạnh bên của hàng hoặc cột.

Hình 1.18. Mạng hình lưới

Ta hãy đánh giá mạng hình lưới theo các tiêu chuẩn ở trên:Giả sử một mạng hình lưới không chứa các kết nối vòng. Đường kính của một mạng hình lưới q chiều với kq nút là q(k-1). Vì vậy, theo quan điểm trên, mạng hình lưới sẽ có nhược điểm là sự di chuyển dữ liệu sẽ làm gia tăng độ phức tạp về truyền thông của thuật toán song song thực hiện trên hình lưới. Tuy nhiên trong thực tế, các máy tính song song tổ chức các bộ xử lý theo mạng hình lưới thực thi một số kết nối nhanh để làm giảm độ phức tạp về truyền thông.Độ rộng phân đôi của một mạng hình lưới q chiều là kq-1 và số cạnh của một nút là 2q.Tổ chức CPU theo mạng Mesh 2 chiều được sử dụng rộng rãi các máy tính mảng bộ vi xử lý như: Goodyear Aerospace ‘s MPPTM, the AMT DAPTM, Intel Paragon và MP-1TM của MasPar.

1.3.2 Mạng hình cây nhị phân (Binary Tree Networks)

Trong cây nhị phân, 2k-1 nút được sắp xếp trong một cây nhị phân hoàn chỉnh với chiều cao k-1. Mỗi nút có nhiều nhất là 3 liên kết. Mỗi nút bên trong (nếu không là nút gốc) có thể giao tiếp được với 2 nút con và 1 nút cha của nó.

Hình 1.19. Mạng hình cây nhị phân

Mạng hình cây nhị phân có 2 dạng: a) mạng tĩnh trong đó mỗi nút đều là các phần tử xử lý và b) là mạng động trong đó chỉ có nút là là các phần tử xử lý; các nút trong là các nút chuyển mạch (cho việc di chuyển dữ liệu giữa các nút).Mạng hình cây nhị phân có đường kính là 2(k-1), độ rộng phân đôi là 1. Như vậy, mạng hình cây nhị phân có đường kính tốt (nhỏ), nhưng độ rộng phân đôi không tốt.

1.3.3 Mạng hình siêu cây (Hypertree networks)

Mạng hình siêu cây thể hiện một cách tiếp cận để xây dựng một mạng với đường kính nhỏ của mạng cây nhị phân và cải tiến độ rộng phân đôi. Một mạng siêu cây cấp k và độ sâu d được nhìn từ hai phía: nhìn phía mặt trước (front view) như một k-cây với chiều cao d. Nhìn từ phía bên cạnh (side view) siêu cây như một cây nhị phân chiều cao d từ dưới lên trên. Kết hợp giữa nhìn phía trước và bên cạnh là mạng hoàn chỉnh. Hình 1.20c là một mạng với cấp 4 chiều cao 2.

Hình 1.20. Một mạng hình siêu cây; a. nhìn từ mặt trước; b. nhìn từ bên cạnh; c. nhìn đầy đủ

Xét một 4-siêu cây với độ cao d có 4d lá và 2d(2d+1-1) nút. Đường kính của mạng này là 2d, độ rộng phân đôi là 2d+1. Số cạnh của một nút không vượt quá 6.Một ví dụ về máy tính song song có cách tổ chức bộ xử lý theo siêu cây (4-siêu cây) là Connection Machine CM-5 multicomputer.

1.3.4 Mạng hình tháp (Pyramid networks)

Mạng hình tháp là sự kết hợp các ưu điểm của mạng hình lưới và mạng hình cây. Một mạng hình tháp kích thước k2 là một 4-cây với độ cao log2k và bổ sung các liên kết giữa các bộ vi xử lý sao cho các bộ vi xử lý trong mỗi mức của mạng hình thành một mạng 2-D mesh (Miller & Stout 1987).Một mạng hình tháp kích thước k2 có nền là một 2-D mesh với k2 bộ vi xử lý. Tổng số bộ vi xử lý trong mạng hình tháp kích thước k2 là (4/3) k2-(1/3). Các mức của mạng hình tháp được đánh số theo chiều tăng và mạng Mesh nền có mức 0, và có một bộ vi xử lý đơn ở đỉnh có mức log2k. Mỗi bộ vi xử lý phía trong được kết nối với 9 bộ vi xử lý khác; trong đó, 1 nút cha, 4 nút trong cùng mức và 4 nút con. Hình 1.21 là một mạng hình tháp có kích thước 16.

Hình 1.21. Một mạng hình tháp có kích thước 16.

Một ưu điểm của mạng hình tháp là trên các mạng hình lưới 2 chiều thì đường kính sẽ giảm. Chẳng hạn, khi một thông điệp được trao đổi từ hai bộ vi xử lý bất kỳ trong mạng thì sẽ di chuyển từ mức này đến mức khác sẽ phải qua các bộ vi xử lý trung gian ít hơn là di chuyển bên trong mạng hình lưới. Đường kính của một mạng hình tháp kích thước k2 là 2 log2k.Khi bổ sung thêm các liên kết không làm tăng đáng kể độ rộng phân đôi. Độ rộng phân đôi đối với một mạng hình tháp kích thước k2 là 2k.Số cạnh trên mỗi nút không vượt quá 9.

1.3.5 Mạng hình bướm (Butterfly networks)

Một mạng hình bướm bao gồm (k+1)2k nút được chia vào k+1 hàng hay bậc (ranks); mỗi hàng chứa n= 2k nút. Các hàng được gán nhãn từ 0 đến k, hàng 0 và k đôi khi được kết hợp lại để cho mỗi nút được kết hợp với 4 nút khác.Giả sử nút (i,j) là nút thứ j trên hàng i, với 0 ≤ i ≤ k và 0 ≤ j ≤ n. Thì nút (i,j) trên hàng i>0 được kết nối tới 2 nút ở hàng i-1 là (i-1,j) và (i-1,m) với m là số nguyên khi ta đảo ngược bít thứ i bên trái nhất (the ith most significant bit) trong biểu diễn nhị phân của j. Ví dụ: hình 1.22, nút(2,5) ở hàng 2 cột 5 sẽ kết nối tới 2 nút là (1,5) và (1,7) vì:5=0101, bít thứ 2 (i=1) là tính từ bên trái nhất là 0 (0,1,2) sau khi đảo sẽ là 0111=7.

Chú ý rằng, nếu nút (i,j) được kết nối tới nút (i-1,m) thì nút (i,m) được kết nối tới nút (i-1,j). Vì vậy, toàn bộ mạng được tổ chức giống như hình bướm nên có tên như vậy. Khi số hàng tăng, thì độ rộng của “cánh” bướm sẽ tăng theo hàm số mũ (exponentially).

Hình 1.22. Một mạng hình bướm

Đường kính của một mạng hình bướm với (k+1)2k nút là 2k và độ rộng phân đôi là 2k-1.Một số máy tính song song dựa trên mô hình này như máy tính đa bộ xử lý BBN TC 2000.

1.3.6 Mạng hình siêu khối (Hypercube networks)

Một mạng kết nối kiểu siêu khối còn được gọi là một n-lập phương nhị phân. Bao gồm 2k nút hình thành lên một siêu khối k-chiều. Các nút được gán nhãn 0,1,2…2k-1. Hai nút cạnh nhau nếu chúng khác nhau chính xác 1 vị trí bít. Hình 1.23 là ví dụ về các mạng siêu khối 0,1,2,3,4 chiều.

Hình 1.23. Các mạng siêu khối 0,1,2,3,4 chiều

Đường kính của một mạng siêu khối với 2k nút là k, độ rộng phân đôi là 2k-1. So với các mạng khác thì mạng siêu khối có đường kính nhỏ so với kích thước của mạng.Số cạnh trên nút là k, chính bằng logarit của số nút trên mạng.Mạng hình siêu khối đã từng trở nên thông dụng nhất đối với cách tổ chức các bộ vi xử lý cho các máy tính đa bộ vi xử lý thế hệ thứ nhất và thứ hai. Một số máy tính song song dựa trên mô hình này là: nCUBE, máy tính mảng các bộ xử lý Connecttion Machine CM-200.

1.3.7 Mạng các chu trình hướng kết nối khối (Cube-Connected Cycles networks)

Mạng các chu trình hướng kết nối khối là mạng siêu khối k chiều với 2k đỉnh. Các chu trình gồm k nút, được hình thành bởi các cột của mạng hình bướm hàng 0 và k kết hợp lại. Với mỗi chiều, mọi chu trình có 1 nút được kết nối tới 1 nút trong chu trình bên cạnh của chiều đó.

Nút (i,j) được kết nối tới nút (i,m) nếu và chỉ nếu m là kết quả khi ta đảo ngược bít thứ i bên trái nhất (the ith most significant bit) trong biểu diễn nhị phân của j. Chú ý rằng, các kết nối khác với mạng hình bướm 1 chút ở chỗ: nếu nút (i,j) được kết nối tới nút (i-1,m) trong mạng hình bướm khi j ≠m, thì nút (i,j) được kết nối tới nút (i,m) trong mạng các chu trình hướng kết nối khối. Tuy nhiên, trong mạng các chu trình hướng kết nối khối, nút (i,j) có thể giao tiếp với nút (i-1,m) theo 2 cách vì có một kết nối trực tiếp từ nút (i,m) tới (i-1,m).

Hình 1.24. Mạng các chu trình hướng kết nối khối 3 chiều

So với mạng siêu khối, tổ chức các bộ vi xử lý theo mạng các chu trình hướng kết nối khối có ưu điểm là: số cạnh trên nút bằng 3 và là hằng số không phụ thuộc vào kích thước của mạng. Tuy nhiên, mạng các chu trình hướng kết nối khối có nhược điểm là: đường kính của mạng gấp 2 lần đường kính của mạng hình siêu khối và độ rộng phân đôi thấp hơn.Một mạng các chu trình hướng kết nối khối kích thước k2k có đường kính là 2k và độ rộng phân đôi là 2k-1.

1.3.8 Mạng hoán vị di chuyển (Shuffle-exchange networks)

Một mạng hoán vị di chuyển bao gồm n=2k nút, được đánh số từ 0,1,2,…,n-1, và só hai loại kết nối là di chuyển (shuffle) và hoán vị (exchange). Các kết nối hoán vị liên kết các cặp nút thứ i với nút thứ 2i modulo (n-1); trừ nút thứ n-1 được kết nối đến chính nó. Hình 1.26 là một mạng hoán vị di chuyển với 8 nút.

Mạng hoán vị di chuyển còn có một tên khác đó là mạng di chuyển hoàn hảo (perfect shuffle). Để dễ hình dung ta xem sự di chuyển của 8 quân bài được đánh số 0,1,2,3,4,5,6,7 trên một chiếc bàn. Nếu chiếc bàn được chia làm hai nửa và sự di chuyển là hoàn hảo thì kết quả cho ta thứ tự sau: 0,4,1,5,2,6,3,7. Ta có thể kiểm nghiêm điều này qua hình 1.25 và để ý rằng vị trí cuối cùng của quân bài bắt đầu với chỉ số i có thể được xác định theo sau sự di chuyển liên kết từ nút i.Giả sử, ak-1 ak-2 … a1 a0 là địa chỉ dưới dạng nhị phân của một nút trong một mạng di chuyển hoàn hảo. Dữ liệu này có thể liên kết tới địa chỉ ak-2 … a1 a0 ak-1,, theo sau là một thao tác hoán chuyển. Nói một cách khác, sự thay địa chỉ của một mẩu dữ liệu sau một thao tác di chuyển tương đương với việc quay trái (left cyclic rotate) địa chỉ 1 bít. Nếu n=2k, thì cần k thao tác di chuyển để chuyển một mục dữ liệu về vị trí ban đầu. Những nút trung gian mà mục dữ liệu bắt đầu ở địa chỉ i di chuyển theo yêu cầu của một dãy các thao tác di chuyển được gọi là chuỗi di chuyển của i (necklace). Nếu một chuỗi di chuyển của i nhỏ hơn k thì được gọi là một chuỗi di chuyển ngắn.

Hình 1.25. Thao tác hoán chuyển trên một mạng hoán vị di chuyển.

Hình 1.26. Một mạng hoán vị di chuyển với 8 nút

Mọi nút trong mạng hoán vị di chuyển đều có hai nút vào và hai nút ra. Độ dài của liên kết dài nhất tăng theo một hàm của kích thước mạng. Số liên kết dài sẽ cải tiến đường kính và độ rộng phân đôi trong mạng hoán vị- di chuyển. Trong mạng hoán vị- di chuyển thì đường kính là lô ga rít đối với số nút. Một mạng với 2k nút thì đường kính là 2k-1 và độ rộng phân đôi bé nhất là (2k-

1/k).Siegel (1979) đã phát triển một cải tiến của mạng hoán vị-di chuyển là mạng Omega, tương đương với mạng hình siêu khối cấp độ k.

1.3.9 Mạng de Bruijn

Mạng de Bruijn bao gồm n=2k nút. Giả sử ak-1 ak-2 … a1 a0 là địa chỉ của một nút trong mạng de Bruijn thì hai nút có liên kết trực tiếp với nút đó sẽ là : ak-2 … a1 a0 0 và ak-2 … a1 a0 1.Số cạnh của một nút là hằng số và độc lập với kích thước mạng. Độ rộng phân đôi của một mạng de Bruijn với 2k nút là 2k/k. Tương tự mạng hoán vị-di chuyển, mạng de Bruijn có chứa các kết nối di chuyển (shuffle).

Hình 1.27. Một mạng de Bruijn với 8 bộ xử lý.

Đường kính của mạng de Bruijn với 2k nút là k.Một số máy tính song song dựa trên mạng de Bruijn như máy Triton/1TM . Đây là một máy tính song song lai giữa hai mô hình SIMD và MIMD được thiết kế bởi trường Đại học Karrlsruhe năm 1992.

1.3.10 Tổng kết về tổ chức các bộ vi xử lý

Trong 9 kiểu tổ chức ta đã xét ở trên được tóm tắt trong bảng sau:

Mạng Số nút Đường kính Độ rộng phân đôi

Số cạnh là hằng số?

1-D hình lưới K k-1 1 đúng

2-D hình lưới k2 2(k-1) K Đúng

3-D hình lưới k3 3(k-1) k2 Đúng

Cây nhị phân 2k-1 2(k-1) 1 Đúng

Siêu cây 4 chiều

2k(2k+1-1) 2k 2k+1 Đúng

Hình tháp (4k2-1)/3 2logk 2k Đúng

Hình bướm (k+1) 2k 2k 2k Đúng

Siêu khối 2k K 2k-1 Không

Hướng kết nối khối có chu trình

k2k 2k 2k-1 Đúng

Hoán vị-di chuyển

2k 2k-1 >=2k-1/k Đúng

de Bruijn 2k K 2k/k Đúng

1.4 Các hệ thống mảng bộ xử lý, đa bộ xử lý, và đa máy tính

1.4.1 Hệ thống mảng bộ vi xử lý (processor arrays)

a. Máy tính vectorMột máy tính vector là một máy tính mà tập lệnh của nó chứa các thao tác trên các vector có hướng hoặc vô hướng (scalar). Nói chung, có hai loại máy tính vector đó là:Bộ xử lý vector kiểu pipeline (pipelined vector processor) có khả năng xử lý các dòng vector (lệnh) từ bộ nhớ đến CPU mà các bộ xử lý toán học có thể thao tác với chúng bằng cơ chế pipeline. Một số máy tính song song có kiểu tổ chức này là Cray-1TM và Cyber-205TM.Mảng bộ xử lý (processor array) là máy tính vector bao gồm một máy tính tuần tự được kết nối đến một tập các phần tử xử lý (processing elements) đồng bộ, riêng biệt có khả năng thực hiện cùng một thao tác trên các dữ liệu khác nhau một cách đồng thời. Máy tính tuần tự thường được gọi là front-end.Front-end là một CPU đa năng chứa chương trình và các dữ liệu không thể xử lý song song. Đồng thời, front-end có thể thực hiện các phần tuần tự của chương trình (trong một chương trình, có thể có nhóm lệnh không thể thực hiện song song được, nhóm lệnh đó phải được thực hiện tuần tự). Mỗi phần tử xử lý có một bộ nhớ cục bộ nhỏ mà nó có thể truy cập trực tiếp. Tập hợp lại, các bộ nhớ cục bộ của các phần tử xử lý lưu trữ vector dữ liệu sẽ được thao tác một cách song song. Khi máy tính front-end gặp một lệnh mà toán hạng của lệnh đó là một vector, nó sẽ phát ra một lệnh yêu cầu các phần tử xử lý thực hiện lệnh đó một cách song song. Mặc dù các phần tử xử lý thực hiện song song, các bộ xử lý này có thể được lập trình để lờ đi bất cứ lệnh không cần thiết nào. Chẳng hạn, trong trường hợp kích thước vector nhỏ hơn số phần tử xử lý, một vài phần tử xử lý sẽ không có dữ liệu để thực hiện lệnh do front-end yêu cầu, chúng sẽ bị idle và được lập trình để lờ đi lệnh này để tránh gây ra lỗi (bug) hoặc ngoại lệ (exception). Một trường hợp khác là khi thực hiện các câu lệnh điều kiện như if…then hoặc if…then…else , một số bộ vi xử lý sẽ bị che (masked) trong qua trình thực hiện do quá trình thực hiện trên máy tính mảng các phần tử xử lý là đồng bộ.Thông thường, các luồng dữ liệu có thể di chuyển bằng một trong ba cách sau: đi từ front-end đến mảng các phần tử xử lý, giữa các phần tử xử lý trong mảng, và đi từ mảng các phần tử xử lý đến front-end. Các phần tử xử lý trao đổi dữ liệu với nhau thông qua một mạng kết nối (interconnection network).

Hình 1.28. Một máy tính mảng các bộ xử lý.

Chính vì vậy, cách thức tổ chức các bộ vi xử lý theo mô hình mạng lưới 2-D là phù hợp nhất. Một số cách tổ chức khác như: hình siêu khối, hình hướng khối có chu trình, và hoán vị-di chuyển cũng được giới thiệu cho máy tính với mảng các bộ xử lý. Máy tính mảng các bộ vi xử lý có một cơ chế rất hiệu quả đối với front-end là phát tán (broadcast) các lệnh và dữ liệu đến các phần tử xử lý. Hơn nữa, máy tính với các mảng bộ vi xử lý cũng hỗ trợ front-end truy cập bộ nhớ cục bộ của bất kỳ phần tử xử lý nào rất hiệu quả. Phân phát các thao tác nhanh và truy cập bộ nhớ hiệu quả đóng vai trò quan trọng trong nhiều thuật toán song song.b. Máy tính CM-200Một ví dụ về máy tính với mảng các bộ vi xử lý là máy tính Connection Machine CM-200 được thiết kế và chế tạo bởi tập đoàn Thinking Machine.Máy CM-200 bao gồm ba thành phần cơ bản: một máy tính front-end, một bộ xử lý song song (parallel processing unit) và một hệ thống vào/ra. Máy tính front-end thông thường là một máy trạm của công ty máy tính Sun. Nó lưu trữ dữ liệu tuần tự và thực hiện phần tuần tự của chương trình. Các dữ liệu song song được lưu trữ trong bộ xử lý song song. Máy tính front-end phân phát (broadcast) các lệnh song song tới bộ xử lý song song để thực hiện. Hệ thống vào/ra tốc độ cao cho phép dữ liệu được di chuyển giữa bộ xử lý song song và các thiết bị vào/ra như các khung vùng đệm (frame buffer) và các ổ đĩa song song (parallel disk devices).

Hình 1.29. Máy tính CM-200.

Máy tính front-end có thể trao đổi dữ liệu với các phần tử xử lý theo ba cách. Nó có thể phân phát (broadcast) một giá trị dữ liệu tới tất cả các phần tử xử lý. Thông qua các tính toán toàn cục, ta có thể tính được tổng, giá trị lớn nhất, OR toàn cục…của một giá trị từ mỗi phần tử xử lý. Bằng việc sử dụng bus bộ nhớ vô hướng (scalar memory), bộ xử lý front-end có thể đọc hoặc ghi các giá trị 32-bít được lưu trữ trên bất kỳ phần tử xử lý nào.Bộ xử lý song song chứa khoảng 2048 đến 65536 phần tử xử lý, một bộ xử lý lệnh tuần tự và các mạng truyền thông giữa các bộ vi xử lý, bộ điều khiển vào /ra và/ hoặc các mô đun vùng đệm khung truyền.

Front-end phân phát các lệnh xử lý song song tới bộ xử lý tuần tự, nó dịch từng lệnh và sinh ra một tập vi lệnh (nanoinstructions). Nó phân phát (broadcast) các vi lệnh này qua một bus truyền tải lệnh (instruction bus) tới các phần tử xử lý, sau đó các phần tử xử lý sẽ thực hiện vi lệnh.PARIS (PARallel Instruction Set) là tập lệnh của máy tính CM-200, làm đơn giản hóa chương trình dịch bằng cách cung cấp các thao tác tương tự như một tập lệnh máy tính điển hình. Một số lệnh PARIS thực hiện các thao tác tính toán trên nhiều loại dữ liệu, những lệnh khác làm thuận tiện việc truyền thông giữa các phần tử xử lý và máy tính front-end.

Bằng việc hỗ trợ các máy ảo, PARIS cũng tạo ra sự ngăn cách an toàn (insulating) giữa người sử dụng với mảng bộ vi xử lý bên dưới. Một chương trình có thể giả sử sự tồn tại của một số lượng các phần tử xử lý bất kỳ, và những máy ảo này được ánh xạ lên các phần tử xử lý vật lý. Tính năng này cho phép cùng một chương trình chạy trên các hệ thống Connection Machine với các số lượng bộ vi xử lý khác nhau.Nhìn chung, bất kỳ khi nào một thao tác (operation) PARIS được thực hiện, mỗi phần tử xử lý có thể thực hiện thao tác nhiều lần, mỗi lần sẽ được bộ xử lý ảo ánh xạ vào. Các phiên bản của bộ nhớ ảo của ba cơ chế hỗ trợ truyền thông cũng tồn tại trong tập lệnh PARIS.Các phần tử xử lý của máy tính CM là các bộ xử lý bít tuần tự (bit-serial processors). Mỗi phần tử xử lý có một cờ trạng thái (contex flag) chỉ ra rằng phần tử xử lý đó được che (screened) hay không. Các phần tử xử lý được che không lưu trữ các kết quả tính toán. Mỗi phần tử xử lý có 3 bít đầu vào (2 bít từ bộ nhớ và 1 bít từ cờ trạng thái) và 2 bít kết quả (1 bít đến bộ nhớ và 1 bít đến cờ trạng thái).

Hình 1.30. Kiến trúc bộ xử lý đôi của máy CM-200.

Một phần tử xử lý có thể tính toán hai hàm Boolean bất kỳ từ 3 đầu vào. Các hàm này được mô tả bằng 2 byte được biểu diễn trong bảng chân lý (Truth table). Nói cách khác, phần tử xử lý tính toán kết quả của hàm Boolean bằng việc tra cứu bảng chân lý từ ba bít đầu vào.Chẳng hạn, bảng chân lý sau được sử dụng để thực hiện phép cộng bít tuần tự (bit-serial addition). Trong trường hợp này, hai hàm trên ba đầu vào sẽ được thực hiện (carry-out) và cộng (sum). Để cộng hai số nguyên k-bít được lưu trữ trong bộ nhớ cục bộ của nó, một phần tử xử lý tải cờ trạng thái (context flag) của bộ xử lý ảo (virtual processor)vào một thanh ghi cờ của phần cứng (vật lý). Tất cả các kết quả của phép toán trên ALU sẽ phản ánh vào trạng thái của cờ này.

Tiếp theo, bộ xử lý sẽ xóa cờ thứ 2 (cờ này có chức năng như một bít nhớ (carry bit). Sau đó, bộ xử lý lặp k lần qua một chu kỳ trong đó nó đọc bít nhớ và một bít của mỗi toán hạng (operand) và tính bít tổng và bít nhớ. Việc tính toán bắt đầu với bít có trọng số bé nhất (least significant bits) của các toán hạng và kết thúc với bít có trọng số cao nhất (most significant bits).

INPUT BITS OUTPUT BITS

Bộ nhớ Bộ nhớ Cờ Bộ nhớ Cờ

0 0 0 0 0

0 0 1 1 0

0 1 0 1 0

0 1 1 0 1

1 0 0 1 0

1 0 1 0 1

1 1 0 0 1

1 1 1 1 1

Một chíp VLSI đơn chứa 16 phần tử xử lý cùng với phần cứng hỗ trợ truyền thông (routing

hardware). Mỗi cặp chíp xử lý chia xẻ một nhóm chip bộ nhớ. Một chíp làm giao diện dấu phảy động (floating point interface chip) và một chip thực hiện các phép tính liên quan đến dấu phẩy động (floating-point execution chip) như hình (3-14, pg 66).Các chip bộ nhớ cung cấp một đường dữ liệu 44 bít được chuyển đổi thành một đường dữ liệu 32 bít và một đường 12 bít mã hóa các mã khắc phục lỗi (error-correcting code). 32 bít dữ liệu có thể được trực tiếp gửi đến 32 phần tử xử lý bít tuần tự. Mỗi bít cho một phần tử xử lý. Tiếp đến, các bít dữ liệu 32 bít sẽ được gửi trực tiếp đến chip giao diện xử lý dấu phảy động. Chip giao diện xử lý dấu phảy động có thể sẽ sử dụng dữ liệu này để điều khiển cho các địa chỉ gián tiếp, hoặc gửi các dữ liệu này đến chip thực hiện các phép tính liên quan đến dấu phẩy động.Chip thực hiện các phép tính liên quan đến dấu phẩy động trả lại kết quả dạng 32-bít. Bộ giao diện sẽ lưu lại những kết quả này vào bộ nhớ. Hiệu suất lớn nhất của bộ tính toán dấu phảy động khi thực hiện các phép toán 32 bít là 20 megaflops. Máy CM có thể có đến 2048 chip thực hiện các phép tính liên quan đến dấu phẩy động và hiệu suất đạt tối đa là 40 Gigaflops. Máy tính CM có ba cơ chế giao tiếp (routing machanisms). Phổ biến và đơn giản nhất là dung bộ định tuyến (router). Có chế này cho phép bất kỳ phần tử xử lý nào cũng có thể giao tiếp được với nhau. Mỗi chíp xử lý có một nút định tuyến có thể phục vụ 16 phần tử xử lý trên chip. Các nút định tuyến được nối dẫn (wired) với nhau để hình thành nên 1 siêu khối. Trong cấu hình tổng quát của máy tính CM bao gồm 65,536 phần tử xử lý được chứa trên 4096 (212) chip xử lý. Vì vậy các bộ xử lý của CM được tổ chức theo một mạng 12 siêu khối 12 chiều. Mỗi thông điệp đi qua các nút định tuyến cho đến khi nó đên được chip chứa bộ vi xử lý đích. Các nút định tuyến (rounter nodes) tự động gửi các thông điệp và thực hiện việc việc cân bằng tải động (dynamic load balancing). Chẳng hạn, đường đi của thông điệp có thể biến đổi, phụ thuộc vào những đường đi đang rảnh rỗi.

Mỗi nút định hướng có một ALU có khả năng thực hiện vài thao tác toán học. Bộ định tuyến kiểm tra xem các thông điệp có cùng đến 1 đích hay không?. Nếu điều đó xảy ra nó sẽ kết hợp các thông điệp dựa trên ngữ nghĩa của các lệnh sẽ được thực hiện. Chẳng hạn như có thể tính tổng, tính giá trị lớn nhất, tính phép tính logic của các giá trị hay đơn giản chỉ là bỏ đi tất cả các giá trị khác và chỉ giữ lại 1 giá trị duy nhất.Có chế định tuyến thứ hai được gọi là NEWS grid. Một mạng hình lưới j chiều có thể được nhúng trong một mạng siêu khối k chiều nếu j ≤ k. Vì vậy, một tập con của các dây nối hỗ trợ bộ định tuyến có thể hình thành một mạng lưới Cartesian, mà Thinking Machine gọi là NEWS grid. Nếu các giao tiếp giữa các phần tử xử lý là lân cận (neighbors) trong một NEWS grid của bất kỳ chiều nào nhỏ hơn hoặc bằng số chiều của siêu khối, thì tốc độ truyền tải thông điệp (message passing speed) sẽ cao hơn nhiều nếu các thông điệp đi qua bộ định tuyến. Hệ thống gửi các thông điệp như vậy sử dụng ba phương pháp truyền tải đặc biệt, hai trong ba phương pháp đó được thực hiện bởi phần cứng.

1.4.2 Máy tính đa bộ xử lý (Multiprocessors)

Máy tính nhiều bộ xử lý (multiple-CPU computers) có một số bộ vi xử lý có thể lập trình được, mỗi bộ vi xử lý có khả năng thực hiện chương trình của nó. Đa bộ vi xử lý có thể là các máy tính có nhiều bộ vi xử lý với một bộ nhớ chia xẻ. Có hai phương thức tổ chức máy tính đa bộ vi xử lý là: chia xẻ bộ nhớ tập trung (Uniform Memory Access- UMA) và chia xẻ bộ nhớ phân tán (Non-uniform Memory Access- NUMA).a. Máy tính đa bộ xử lý chia xẻ bộ nhớ tập trung (UMA multiprocessors)Cách thức bộ vi xử lý liên lạc đơn giản nhất là giả sử rằng tất cả các bộ vi xử lý làm việc qua cơ chế chuyển mạch tập trung tới bộ nhớ chia xẻ tập trung như hình (?).

Hình 1.31. Máy tính đa bộ xử lý chia xẻ bộ nhớ tập trung truy cập bộ nhớ toàn cục và thiết bị vào/ra

thông qua cơ chế chuyển mạch tập trung

Có nhiều cách thực thi bộ nhớ chuyển mạch này, bao gồm một bus chung tới bộ nhớ toàn cục, một bộ chuyển mạch chéo (crossbar switch) và một mạng chuyển mạch gói. Máy tính Encore MultimaxTM và Sequent Symmetry S81TM là các ví dụ của máy tính đa bộ xử lý chia xẻ bộ nhớ tập trung thương mại.Các hệ thống sử dụng một bus như Multimax hay Symmetry được giới hạn bằng kích thước do nhiều bộ vi xử lý chia xẻ một bus trước khi nó bị bão hòa (saturated). Trong trường hợp các hệ

thống sử dụng một bộ chuyển mạch chéo, chi phí của chuyển mạch sẽ trở thành mẫu số, điều này giới hạn số lượng bộ xử lý được kết nối. Máy tính đa bộ xử lý chia xẻ bộ nhớ tập trung dựa trên các mạng chuyển mạch có thể có một số lượng lớn các bộ xử lý. Mặc dù chưa có máy tính thương mại nào có kiến trúc như vậy xuất hiện, một máy tính thử nghiệm dựa trên máy tính đa bộ xử lý chia xẻ bộ nhớ tập trung có tên là NYU Ultracomputer dựa trên mạng chuyển mạch omega (một biến thể của mạng hoán vị-di chuyển). Chi phí cho một hệ thống với p bộ xử lý dựa trên mạng omega là O (plogp) thấp hơn so với chi phí O(p2) cho hệ thống dựa trên chuyển mạch chéo.

Hình 1.32. Một máy tính đa bộ xử lý UMA.

b. Máy tính đa bộ xử lý chia xẻ bộ nhớ phân tán (NUMA multiprocessors)Máy tính đa bộ xử lý chia xẻ bộ nhớ phân tán giống máy tính đa bộ xử lý chia xẻ bộ nhớ tập trung ở điểm là chúng cùng chia xẻ không gian địa chỉ nhớ. Nhưng chúng khác nhau bởi điểm cơ bản: Máy tính đa bộ xử lý chia xẻ bộ nhớ phân tán sử dụng bộ nhớ phân tán. Mỗi bộ xử lý có riêng một bộ nhớ cục bộ và không gian địa chỉ nhớ chia xẻ là sự kết hợp của các bộ nhớ cục bộ này. Thời gian cần thiết để truy cập từng bộ nhớ cục bộ trên máy tính đa bộ xử lý chia xẻ bộ nhớ phân tán phụ thuộc vào vị trí cục bộ đối với bộ xử lý.Một ví dụ về Máy tính đa bộ xử lý chia xẻ bộ nhớ phân tán là máy tính TC2000 được thiết kế và sản xuất bởi công ty BBN Systems and Technologies ở thành phố Cambridge, bang Massachusetts- Hoa kỳ. Máy tính TC 2000 có 128 nút xử lý. Mỗi nút xử lý gồm một CPU Motorola 88100, ba chip Motorola 88200 cung cấp 2 loại bộ nhớ cache là bộ nhớ cache lệnh và cache dữ liệu với kích thước từ 4 đến 16 MB, và giao diện chuyển mạch dựa trên mạng hình bướm và bus VME (hình (?)). Các giao dịch dựa trên bus kết nối các hệ thống bộ xử lý con.

Hình 1.33. Một nút xử lý của máy tính BBN TC2000

Hiệu suất lớn nhất của một bộ xử lý đơn là 20 megaflop. Một máy tính TC2000 với 128 bộ xử lý có thể đạt tới hiệu xuất khoảng 2.5 gigaflop. Phần cứng trên mỗi nút xử lý biến đổi địa chỉ ảo 32 bít thành địa chỉ vật lý 34 bít. Địa chỉ vật lý có thể trong bộ nhớ cache, cùng bộ nhớ cục bộ trên bộ xử lý hoặc có thể là bộ nhớ cục bộ trên một xử lý khác. Tốc độ truy nhập bộ nhớ cache là nhanh nhất. Dữ liệu cục bộ (private data) và dữ liệu chia sẻ chỉ đọc (read-only shared data), chẳng hạn như mã nguồn chương trình, có thể được

lưu trong bộ nhớ cache. Dữ liệu từ bộ nhớ vật lý của bộ xử lý có thể được đọc lên bus. Dữ liệu từ bộ nhớ của bộ xử lý khác có thể được lấy bằng cách gửi một yêu cầu qua mạng chuyển mạch hình bướm.Máy TC 2000 không phải duy trì sự nhất quán dữ liệu trên các bộ nhớ cache của các bộ xử lý. Đó là lý do tại sao mà các hệ điều hành chỉ đưa một số lượng hạn chế dữ liệu vào bộ nhớ cache.Hình (3-18 và 3-19) minh họa một chuyển mạch kiểu hình bướm. Mỗi nút của chuyển mạch là một phần tử chuyển mạch VLSI với 8 đầu vào và 8 đầu ra. Vì vậy, số phần tử chuyển mạch trong một máy tính với p bộ xử lý là plog8p. Luồng dữ liệu qua các chuyển mạch được lưu trong các gói; và các bít địa chỉ định tuyển từ nơi phát đến nơi nhận.

Hình 1.34. Chuyển mạch trên máy TC-2000.

Do mỗi bộ xử lý có một giao diện VME, dung tích I/O của hệ thống được mở rộng theo số lượng CPU. Các giao diện VME cung cấp khả năng truy nhập tới các thiết bị vào/ra khác nhau, bao gồm cả các bộ biến đổi A/D, D/A, bộ nhớ ngoài, và các bộ xử lý đồ họa. Một cửa sổ 16 MB trong mỗi không gian địa chỉ bus VME được ánh xạ vào địa chỉ toàn cục của hệ thống. Nên mỗi bộ xử lý đều có tiềm năng truy cập vào mọi thiết bị vào/ra.Một máy tính khác, hệ thống xử lý chủ TCS (Test and Control System) cung cấp các chức năng quan trọng. Bộ xử lý TCS chủ cung cấp một giao diện cho TCS. Nó cũng tải các chương trình khởi động vào bộ nhớ của bộ xử lý tại thời điểm hệ thống khởi động, kết hợp với các hoạt động của bộ xử lý thợ (slaver processor), và nhận các thông điệp được gửi bởi các bộ xử lý thợ. Bộ xử lý chủ TCS được kết nối tới bộ xử lý thợ qua một bus chẩn đoán (diagnostic bus), nó được định vị trong chip của bộ xử lý và trong mọi module chuyển mạch, và nó tiếp tục theo dõi các lỗi của hệthống.

1.4.3 Hệ thống đa máy tính (Multicomputers)

Một kiến trúc khác của đa bộ xử lý là hệ thống đa máy tính. Hệ thống đa máy tính không có bộ nhớ chia xẻ. Mỗi bộ xử lý có riêng một bộ nhớ cục bộ (private memory) và tương tác với nhau qua trao đổi thông điệp (message passing). Hiện nay đã có nhiều hệ thống đa máy tính thương mại như Intel ‘s Paragon XP/S, Meiko Computing SurfaceTM, nCUBE ‘s nCUBE, Parsytec ‘s SuperClusterTM, và Thinking Machine ‘s CM-5.Một đặc điểm nổi trội của hệ thống đa máy tính mới là cách thức bộ vi xử lý giao tiếp với nhau. Các thế hệ đa máy tính đầu tiên như Intel iPSCTM, nCUBE/10TM và các hệ thống dựa trên T800 TransputerTM, được đặc trưng bởi phần mềm hỗ trợ lưu trữ và chuyển tiếp thông điệp (Fig. 3-20). Để gửi một thông điệp từ một bộ xử lý đến một bộ xử lý không liền kề (nonadjacent processor), các bộ xử lý trung gian nằm trên đường đi của thông điệp sẽ có nhiệm vụ lưu trữ chuyển thông điệp đó đến bộ xử lý kế tiếp. Thậm chí nếu sự truyền tải dữ liệu được hoàn thành qua các kênh DMA, CPU sẽ bị treo vào thời điểm truyền tải dữ liệu bằng DMA.Ngược lại, hệ đa máy tính thế hệ thứ hai như Intel iPSC/2TM, Intel iPSC/850TM và nCUBE 2 có định tuyến chuyển mạch thông điệp (circuit-switched message routing). Chẳng hạn, Intel các nút trong máy tính iPSC/2TM và Intel iPSC/850TM có card logic định tuyến được gọi là mô đun kết nối trực tiếp (Direct-Connect Module-DCM). Các mô đun kết nối trực tiếp thiết lập nên một mạch điện (circuit) kết nối từ nút nguồn đến nút đích. Mỗi khi một mạch được thiết lập, các luồng thông điệp trong các đường dẫn xen kẽ (pipelined) sẽ đi từ nút nguồn đến nút đích và thông điệp không được lưu trong các nút trung gian. Một thông điệp được truyền từ nút này đến nút khác (không ở cạnh nhau) sẽ không yêu cầu treo CPU mà chỉ cần kích hoạt các mô đun kết nối trực tiếp để điều khiển quá trình truyền thông.

Hình 1.35. Mô đun kết nối trực tiếp trên đa máy tính iPSC/2.

Trong mô hình lưu trữ và chuyển tiếp (store-and-forward), thời gian cần thiết để gửi một thông điệp từ bộ xử lý này đến bộ xử lý khác sẽ tăng tuyến tính đối với “bước nhảy” (hop) của thông điệp để tới được đích của nó. Ngược lại với mô hình lưu trữ và chuyển tiếp, thời gian cần thiết để

gửi một thông điệp từ bộ xử lý này đến bộ xử lý khác trong một chuyển mạch sẽ không phụ thuộc vào khoảng cách giữa các bộ vi xử lý.a. Máy tính nCUBE 2Máy tính nCUBE 2 được chế tạo bởi công ty nCUBE tại thành phố Foster, Hoa kỳ. Máy tính nCUBE 2 có ba thành phần chính: một máy tính front-end, một mảng các bộ xử lý back-end và các thiết bị vào/ra song song (hình 3-22). Máy tính nCUBE 2 tương tự như máy tính mảng các bộ vi xử lý. Tuy nhiên, hai kiến trúc này có một điểm khác nhau cơ bản là: máy tính front-end của mảng các bộ xử lý điều khiển các hoạt động của các phần tử xử lý. Nó thực hiện các phép tính đơn giản một cách đồng bộ. Ngược lại, các bộ xử lý trong phần back-end của máy tính nCUBE 2 là các CPU với đầy đủ tính năng (full-fledged CPUs) và những CPU này thực hiện các dòng lệnh của chúng một cách song song.

Hình 1.36. Sơ đồ khối của đa máy tính nCUBE2.

Máy tính nCUBE 2 có tới 8192 nút xử lý. Mỗi nút xử lý có hiệu xuất tối đa 2.5 megaflop. Vì vậy, theo lý thuyết thì hiệu xuất tối đa của máy tính nCUBE 2 là 20 gigaflops. Mỗi nút xử lý có một bộ nhớ chính với kích thước từ 1 đến 64 MB.Các bộ xử lý back-end được tổ chức trong một siêu khối. Máy tính nCUBE 2 là thế hệ thứ hai của hệ thống đa máy tính nên kỹ thuật truyền thông giữa các bộ xử lý là định tuyến cứng (hardware-routed). Các kênh truyền thông DMA hình thành nên các cạnh của siêu khối. Tốc độ truyền dữ liệu lớn nhất giữa các bộ xử lý là 2.2 MB/ giây.Mỗi nút có một kênh DMA dùng cho việc truyền tải dữ liệu từ/đến các thiết bị vào/ra. Các kênh vào/ra có cùng tốc độ truyền với các kênh truyền của các nút trong mạng.Các hệ đa máy tính đầu tiên có hai vấn đề liên quan đến bộ xử lý front-end. Thứ nhất, công suất (power) của bộ xử lý front-end không tỉ lệ (scale) với các bộ xử lý back-end. Nếu số người dùng tỉ lệ với số bộ xử lý, thì tại một số thời điểm, front-end sẽ không thể hỗ trợ người sử dụng. Thứ hai, bộ xử lý front-end cách biệt với các bộ xử lý back-end.b. Máy tính Connection Machine CM-5Máy tính CM-5 là hệ thống đa máy tính đầu tiên được chế tạo bởi công ty Thinking Machine tại Cambridge, bang Masachusetts- Hoa kỳ. Thinking Machine cho rằng vì máy tính CM-5 hỗ trợ

phần cứng đồng bộ nhanh và đa bộ xử lý. Máy tính CM-5 là kiến trúc phù hợp cho việc thực hiện cả dữ liệu song song và chương trình điều khiển song song.Hình (3-23) là một sơ đồ khối của CM-5. Các nút xử lý được gán nhãn P, thực hiện chương trình người dùng. Các bộ xử lý điều khiển (Control Processors) có nhãn là CP thực hiện như bộ quản lý phân hoạch (partition managers) front-ends cho các cụm của các nút xử lý. Các bộ xử lý điều khiển vào/ra làm nhiệm vụ điều khiển các thiết bị vào/ra.

Hình 1.37. Sơ đồ khối của đa máy tính CM-5

Kiến trúc của máy tính CM-5 cũng khắc phục được một số vấn đề gắn với bộ xử lý front-end của các hệ thống đa máy tính trước đây. Trước hết, hệ thống có thể có nhiều bộ xử lý front-end và các bộ quản lý phân hoạch. Thứ hai, các bộ xử lý này dựa trên kiến trúc SPARC, giống với các bộ xử lý back-end. Thứ ba, các bộ phân hoạch là một phần của mạng định tuyến có cùng dữ liệu với các bộ xử lý back-end.Tổ chức của bộ xử lý trong máy tính CM-5 là một 4 siêu cây (hình 3-3). Các bộ xử lý là các lá của cây và các nút bên trong định tuyến dữ liệu giữa các lá. Dải thông (bandwidth) tối thiểu của mạng là 5MB/giây.Mỗi nút CM-5 bao gồm một bộ xử lý SPARC, phần cứng giao diện mạng, một bộ nhớ chính 32MB và 4 bộ xử lý vector kiểu pipeline, mỗi bộ xử lý vector có thể xử lý được 32 triệu phép tính dấu phảy động trong một giây. Máy tính CM-5 với cấu hình đầy đủ (fully-configured) có tới 16,384 nút, 512 GB bộ nhớ chính và hiệu xuất lớn nhất có thể đạt tới 2 Teraflops (về mặt lý thuyết).

1.5 Kết chươngTrong chương này, ta đã thảo luận hai vấn đề chính: kiến trúc và tổ chức các bộ vi xử lý trong máy tính song song. Phần đầu của chương là phần tổng quan về tính toán song song (parallel

computing). Bắt nguồn từ các yêu cầu khối lượng tính toán lớn trong hầu hết các ứng dụng trong đời sống: khoa học, thương mại…là các bài toán đòi hỏi khả năng tính toán vượt xa so với hệ thống tính toán hiện tại. Trong khi đó, tốc độ nhanh nhất của máy tính với một bộ xử lý đơn ngày càng tăng nhưng còn kém tốc độ của máy tính với nhiều bộ xử lý. Các thuật ngữ cơ bản và lịch sử phát triển của máy tính song song cũng được đề cập trong phần đầu của chương.Theo Flynn, tất cả các máy tính được chia thành 4 loại dựa trên xử lý song song hoặc tuần tự của dòng lệnh và dòng dữ liệu. Trong đó, các máy tính tuần tự thuộc loại máy tính một dòng lệnh, một dòng dữ liệu (SISD); bao gồm cả các máy tính tích hợp nhiều bộ chức năng hay xử lý nhưng chỉ thực hiện một dòng lệnh được gọi là systolic. Các máy tính với một mảng các bộ xử lý thuộc loại máy tính một dòng lệnh, nhiều dòng dữ liệu (SIMD). Các máy tính systolic với mảng các bộ vi xử lý thuộc loại nhiều dòng lệnh, một dòng dữ liệu (MISD). Cuối cùng, là các máy tính nhiều CPU (multiple-CPU machines) như máy tính đa bộ xử lý (multiprocessors), đa máy tính (multicomputers) thuộc loại máy tính nhiều dòng lệnh, nhiều dòng dữ liệu (MIMD).Tiếp đến, có 9 cách thức tổ chức các bộ vi xử lý trong các máy tính song song được thảo luận. Các mô hình tổ chức đó là: mạng hình lưới, mạng hình cây nhị phân, mạng hình siêu cây, mạng hình tháp, mạng hình cánh bướm, mạng hình siêu khối, mạng các chu trình hướng kết nối khối, và mạng de Bruijn. Đồng thời, ta cũng đánh giá cách thức tổ chức của từng mạng theo 3 tiêu chuẩn: đường kính, độ rộng phân đôi và số cạnh trên một nút. Các tiêu chuẩn này giúp chúng ta lựa chọn cách thức tổ chức các bộ vi xử lý để thực hiện các giải thuật song song một cách hiệu quả và phù hợp nhất theo quan điểm của nhà thiết kế và chế tạo máy tính song song một cách thực tế.Máy tính mảng các bộ vi xử lý được thực thi từ mô hình kiến trúc SIMD, trong đó xử lý song song đạt được thông qua sự áp dụng một thao tác đơn trên một tập dữ liệu. Sẽ là không thực tế nếu ta xây dựng một máy tính mảng các bộ xử lý trong đó các bộ xử lý chia sẻ một bị nhớ toàn cục. Trong thực tế, mỗi bộ xử lý trong máy tính này có một bộ nhớ cục bộ. Cách thức tổ chức các bộ vi xử lý quyết định cách thức trao đổi dữ liệu giữa các bộ xử lý. Máy tính CM-200 là một máy tính với các mảng bộ vi xử lý theo mô hình SIMD đã được thương mại hóa và ứng dụng rộng rãi trên thực tế.Các máy tính MIMD là các máy tính đa năng của tính toán song song. Chúng bao gồm nhiều CPU mà mỗi CPU thực hiện một dòng lệnh độc lập và không đồng bộ. Các máy tính MIMD có thể được phân loại bằng cách truy cập bộ nhớ. Máy tính đa bộ xử lý UMA có một không gian địa chỉ chia sẻ và khoảng cách từ một CPU tới một ô nhớ bất kỳ là hằng số. Máy tính đa bộ xử lý NUMA cũng có bộ nhớ chia sẻ. Nhưng khoảng cách mỗi ô nhớ đến các bộ xử lý là khác nhau. Hệ thống đa máy tính không có bộ nhớ chia sẻ mà mỗi CPU có một bộ nhớ cục bộ riêng và các bộ xử lý giao tiếp với nhau thông qua cơ chế truyền thông điệp (message passing).

1.6 Câu hỏi và bài tập

1.6.1 Câu hỏi

1. Trình bày về xu hướng thiết kế máy tính hiện đại ?.

2. Trình bày phân loại máy tính theo Flynn?. Theo cách phân loại này thì một máy tính cá nhân với chip Dual-core (hai nhân) hiện nay thuộc loại nào?

3. Trình bày về máy tính SIMD ?. Hãy so sánh ưu và nhược điểm của máy tính SIMD với bộ nhớ phân tán và bộ nhớ chia sẻ?.

4. Hãy tìm một ứng dụng thực tế có thể thực hiện trên máy SIMD với bộ nhớ chia sẻ.

5. Trình bày về máy tính MIMD ?. Máy tính MIMD với bộ nhớ chia sẻ và phân tán.

6. Tìm một ứng dụng cụ thể trên máy tính MISD?.

7. Đánh giá các cách thức tổ chức bộ vi xử lý thông qua các tiêu chuẩn gì ?. Ý nghĩa của từng tiêu chuẩn.

8. Trình bày cách thức tổ chức các bộ vi xử lý theo mạng hình lưới. Ưu và nhược điểm của cách thức tổ chức này?.

9. Trình bày cách thức tổ chức các bộ vi xử lý theo mạng hình cây. Ưu và nhược điểm của cách thức tổ chức này?.

10. Trình bày cách thức tổ chức các bộ vi xử lý theo mạng hình siêu cây. Ưu và nhược điểm của cách thức tổ chức này?.

11. Trình bày cách thức tổ chức các bộ vi xử lý theo mạng hình tháp. Ưu và nhược điểm của cách thức tổ chức này?.

12. Trình bày cách thức tổ chức các bộ vi xử lý theo mạng hình siêu khối. Ưu và nhược điểm của cách thức tổ chức này?.

13. Trình bày cách thức tổ chức các bộ vi xử lý theo mạng hình bướm. Ưu và nhược điểm của cách thức tổ chức này?.

14. Trình bày cách thức tổ chức các bộ vi xử lý theo mạng chu trình hướng kết nối khối. Ưu và nhược điểm của cách thức tổ chức này?.

15. Trình bày cách thức tổ chức các bộ vi xử lý theo mạng di chuyển hoán vị. Ưu và nhược điểm của cách thức tổ chức này?.

16. Trình bày về máy tính mảng các bộ vi xử lý?.

17. Trình bày về máy tính đa bộ xử lý UMA Sequent Symmetry?

18. Trình bày về máy tính đa bộ vi xử lý NUMA TC 2000?

19. Trình bày về hệ thống đa máy tính?

20. So sánh kiến trúc của máy tính nCUBE2 và CM-5?

1.6.2 Bài tập

1. Người ta cần tính tổng của hai véc tơ u và v trên một máy tính SIMD với 100 bộ vi xử lý; Hãy tính hiệu suất của máy tính SIMD khi thực hiện chương trình này biết rằng:- Kích thước (số phần tử) của mỗi véc tơ u hoặc v là 350.- Mỗi lệnh cộng thực hiện trên một bộ xử lý mất 10-9 giây.- Chương trình tính tổng trên đã được viết tối ưu cho máy SIMD

2. Một chương trình tính tổng các phần tử của một véc tơ v trên một máy tính SIMD với 1000 bộ vi xử lý; Hãy tính hiệu suất của máy tính SIMD khi thực hiện chương trình này biết rằng:- Kích thước (số phần tử) của véc tơ v là 2000.- Mỗi lệnh cộng thực hiện trên một bộ xử lý mất 10-8 giây.- Chương trình trên đã được viết tối ưu cho máy SIMD

3. Trình bày về cách thức tổ chức 1024 bộ vi xử lý theo mạng hình bướm? Bộ vi xử lý (7,9) sẽ được kết nối với hai bộ vi xử lý nào ở hàng thứ 6.?

4. Trình bày sự khác nhau giữa một mạng siêu khối 4 chiều và một mạng chu trình hướng kết nối khối cấp 4.

5. Hãy so sánh cách thức tổ chức bộ vi xử lý theo hai mạng: hình lưới kích thước 64 và hình tháp kích thước 64.

6. Trình bày về cách thức tổ chức 1024 bộ vi xử lý theo mạng hình siêu khối? Bộ vi xử lý 0011101010 sẽ được kết nối với các bộ vi xử lý nào trong mạng?

7. Trình bày về cách thức tổ chức 64 bộ vi xử lý theo mạng chu trình hướng kết nối khối. Bộ vi xử lý P1,2,3 sẽ được kết nối với các bộ vi xử lý nào trong mạng?

8. Một chương trình tính tích vô hướng của hai véc tơ u và v trên một máy tính SIMD với 1000 bộ vi xử lý; Hãy tính hiệu suất của máy tính SIMD khi thực hiện chương trình này biết rằng:- Kích thước (số phần tử) của mỗi véc tơ u hoặc v là 1000.- Mỗi lệnh cộng hoặc nhân thực hiện trên một bộ xử lý mất 10-10 giây.- Chương trình trên đã được viết tối ưu cho máy SIMD

9. Cho một mạng hoán vị- di chuyển, chứng minh rằng nếu một kết nối di chuyển (shuffle) nối nút i với nút j thì j là sẽ là kết quả của phép quay trái một bít trong biểu diễn nhị phân của i.

10. Tính hiệu suất tốt nhất của một chương trình tính tổng S=1+2+…+100 trên một máy tính CM-200 với 50 bộ vi xử lý. Biết rằng, tại một thời điểm, mỗi bộ vi xử lý có thể thực hiện được một phép cộng cho hai số và thời gian thực hiện một phép công trên một bộ xử lý là 10-8

.

CHƯƠNG 2 : CÁC THUẬT TOÁN SONG SONGChương này trình bày một số vấn đề sau:- Mô hình PRAM là mô hình làm đơn giản việc thiết kế các giải thuật song song. Trong mô hình PRAM độ phức tạp về truyền thông được bỏ qua và số lượng bộ vi xử lý tham gia thực hiện các thuật toán là vô hạn. Cùng với mô hình PRAM, ta tìm hiểu một số thuật toán song son đơn giản thiết kế cho máy PRAM.- Các thuật toán song song nhân hai ma trận; trong phần này ta trình bày 3 thuật toán song song để giải quyết bài toán nhân hai ma trận. Thuật toán thứ nhất là song song hóa từ thuật toán nhân hai ma trận tuần tự. Thuật toán thứ hai là nhân hai ma trận theo khối, và cuối cùng là thuật toán nhân hai ma trận trên hệ thống nhiều máy tính tổ chức theo hình siêu khối.- Thuật toán sắp xếp song song: Ba thuật thuật toán song song giải quyết bài toán sắp xếp được thảo luận trong phần này. Thuật toán sắp xếp song song hoán chuyển chẵn lẻ trên máy tính có các bộ xử lý được tổ chức theo mạng hình lưới một chiều; Thuật toán sắp xếp song song trộn Bitonic và thuật toán song song dựa trên Quicksort.- Thuật toán tìm kiếm song song trên danh bạ: được song song hóa từ giải thuật tuần tự Ellis. Đồng thời, ta cũng tìm hiểu về một giải thuật tìm kiếm song song rất hiệu quả với các tiến trình thực hiện các thao tác trên cây tìm kiếm nhị phân được chạy song song do Manber và Ladner đề xuất.- Thuật toán song song trên đồ thị: trình bày về hai giải thuật được song song hóa từ giải thuật tuần tự của Moore để giải bài toán tìm đường đi ngắn nhất trên một đồ thị có trọng số; và song song hóa từ giải thuật Kruskal để giải bài toán tìm cây khung nhỏ nhất trên đồ thị vô hướng, có trọng số.Phần cuối cùng của chương là phần kết chương và bài tập dành cho người học.

2.1 Mô hình PRAMPhần này trình bày về mô hình máy truy cập ngẫu nhiên song song (parallel random access machine) PRAM trong tính toán song song. Trong khi các thuật toán tuần tự dưa trên mô hình máy tính von Neumann hay Turing thì mô hình PRAM cho phép các nhà thiết kế các thuật toán song song xem năng lực xử lý (processing power) như nguồn tài nguyên vô hạn như các nhà lập trình máy tính xem bộ nhớ ảo là tài nguyên không hạn chế. Mô hình PRAM làm đơn giản quá trình thiết kế thuật toán song song nhưng không thực tế vì ta bỏ qua độ phức tạp truyền thông giữa các bộ xử lý.

2.1.1 Mô hình xử lý tuần tự

Máy tính truy cập ngẫu nhiên (random access machine) RAM bao gồm một bộ nhớ, một băng từ chỉ đọc chứa đầu vào, một băng từ (tape) chỉ ghi chứa đầu ra, và một chương trình (hình 2-1). Chương trình không được lưu trong bộ nhớ và không thể thay đổi. Băng đầu vào chứa một dãycác số nguyên. Tại mỗi thời điểm một giá trị đầu vào được đọc, đầu đọc sẽ dịch chuyển một ô vuông. Tương tự, khi một giá trị đầu ra được ghi vào băng thì đầu ghi được dịch chuyển một lần. Bộ nhớ là một dãy vô hạn các thanh ghi kí hiệu là r0, r1,… mỗi thanh ghi có thể chứa một số nguyên.Các lệnh có thể tương tự như các lệnh trên một máy tính thực. Vì vậy, một máy tính RAM có thể có các lệnh load, store, write, add, subtract, multiply, divide, jump …Độ phức tạp về thời gian trong trường hợp xấu nhất (worst-case time complexity) của một chương trình RAM là một hàm f(n) chỉ thời gian lớn nhất thực hiện bởi chương trình cho mọi đầu vào có kích thước n. Độ phức tạp về thời gian kỳ vọng trung bình (expected time complexity) của chương trình là thời gian trung bình thực hiện của chương trình đối với mọi đầu vào kích thước n. Các khái niệm tương tự đối với độ phức tạp về không gian trong trường hợp xấu nhất và trung bình.

Hình 2.1. Mô hình xử lý tuần tự RAM

Có hai cách để đo độ phức tạp về thời gian và không gian dựa trên mô hình RAM. Đánh giá theo tiêu chuẩn đồng nhất chi phí (uniform cost criterion) phát biểu rằng mỗi lệnh của RAM đòi hỏi tiêu tốn một đơn vị thời gian để thực hiện và mỗi thanh ghi tương đương với một đơn vị không gian (bộ nhớ). Đánh giá theo tiêu chuẩn chi phí lô ga (logarithmic cost criterion) thì cho rằng bộ nhớ thực tế bị giới hạn về khả năng lưu trữ (kích thước). Đánh giá theo tiêu chuẩn đồng nhất chi phí là phù hợp nếu các giá trị được thao tác bởi chương trình có thể lưu trữ trong một từ máy.

2.1.2 Mô hình tính toán song song PRAM

Một mô hình PRAM gồm một bộ điều khiển, một bộ nhớ toàn cục, và một tập vô hạn các bộ xử lý; mỗi bộ xử lý có bộ nhớ cục bộ riêng. Mặc dù các bộ xử lý đang hoạt động thực hiện các lệnh giống nhau; nhưng mỗi bộ xử lý có một chỉ số duy nhất và chỉ số này có thể được sử dụng để

kích hoạt (enable) hoặc dừng hoạt động (disabled). Chỉ số này cũng được gắn với vị trí bộ nhớ mà bộ xử lý truy nhập đến.

Hình 2.2. Mô hình xử lý song song PRAM

Xử lý PRAM bắt đầu với đầu vào được lưu trong bộ nhớ toàn cục và một bộ vi xử lý được kích hoạt. Tại mỗi bước, một bộ xử lý đang hoạt động có thể thực hiện một trong các thao tác: đọc dữ liệu từ bộ nhớ riêng cục bộ hay bộ nhớ toàn cục, thực hiện một thao tác xử lý RAM, ghi dữ liệu vào bộ nhớ riêng cục bộ hoặc toàn cục, hoặc kích hoạt bộ xử lý khác. Tất cả các bộ xử lý đang hoạt động phải thực hiện cùng một lệnh, có thể trên các địa chỉ nhớ khác nhau. Xử lý PRAM kết thúc khi bộ xử lý cuối cùng dừng hoạt động. Các mô hình PRAM khác nhau ở chỗ làm thế nào để giải quyết (handle) được các xung đột từ thao tác ghi và đọc bộ nhớ toàn cục. Chẳng hạn, khi có nhiều hơn một bộ xử lý đọc hoặc ghi vào cùng một địa chỉ trong bộ nhớ. Các kết quả nghiên cứu về các thuật toán PRAM dựa vào một trong các cơ chế sau sau đây:

1. EREW (Exclusive Read Exclusive Write): Không cho phép xung đột Đọc và Ghi.2. CREW (Concurrent Read Exclusive Write): Cho phép xung đột Đọc và không cho phép

xung đột Ghi. Tại cùng một thời điểm, nhiều bộ xử lý có thể đọc đến cùng một địa chỉ trong bộ nhớ toàn cục nhưng không có quá một bộ xử lý được phép ghi.

3. CRCW (Concurrent Read Concurrent Write): Cho phép xung đột Đọc và cho phép xung đột Ghi. Tại cùng một thời điểm, nhiều bộ xử lý có thể đọc hoặc ghi cùng một địa chỉ trong bộ nhớ toàn cục theo một trong ba mô hình dưới đây:

- Thông thường (common): tại cùng một thời điểm, tất cả các bộ xử lý phải ghi cùng một giá trị vào cùng một địa chỉ trong bộ nhớ toàn cục.

- Ngẫu nhiên (arbitrary): tại cùng một thời điểm, nếu có nhiều bộ xử lý đồng thời ghi vào một địa chỉ trong bộ nhớ toàn cục, thì một trong số các bộ xử lý đó được chọn ngẫu nhiên sẽ được ghi giá trị vào ô nhớ đó.

- Ưu tiên (priority): tại cùng một thời điểm, nếu có nhiều bộ xử lý đồng thời ghi vào một địa chỉ trong bộ nhớ toàn cục, thì bộ xử lý có chỉ số nhỏ nhất sẽ được ghi giá trị vào ô nhớ đó.

2.1.3 Một số thuật toán PRAM

Khi một thuật toán PRAM có độ phức tạp về thời gian tốt hơn (thấp hơn) so với một thuật toán RAM đã được tối ưu tương ứng, thì đó là do trong thuật toán PRAM đã có các lệnh được xử lý song song. Do thuật toán PRAM bắt đầu với một bộ xử lý hoạt động nên mọi thuật toán PRAM luôn có hai pha. Trong pha đầu, một số lượng đủ lớn bộ xử lý tham gia thực hiện thuật toán được kích hoạt. Trong pha thứ hai, các bộ xử lý đã được kích hoạt thực hiện xử lý thuật toán song song.Với một bộ xử lý ban đầu được kích hoạt, dễ nhận thấy rằng ta phải cần đến [logP] bước để kích hoạt P bộ xử lý.

Hình 2.3. Thời gian kích hoạt các bộ xử lý

Để kích hoạt các bộ vi xử lý hoạt động từ một bộ xử lý, các thuật toán PRAM thực hiện một câu lệnh sau:

Spawn(<tên các bộ vi xử lý>)

Để dễ dàng hiểu về pha thứ 2 của thuật toán PRAM, ta giả sử khi tham chiếu (reference) đến các thanh ghi toàn cục như một dãy các tham chiếu. Nghĩa là, có một ánh xạ từ dãy các tham chiếu này đến các thanh ghi toàn cục tương ứng.Cấu trúc điều khiển

For all <danh sách các bộ vi xử lý> do <danh sách các câu lệnh> endforMô tả đoạn mã được thực hiện song song bởi các bộ xử lý cụ thể.Bên cạnh các cấu trúc điều khiển trên, PRAM cũng sử dụng cấu trúc điều khiển quen thuộc như: if …then…else…endif, for…endfor, while…endwhile và repeat…until.Dưới đây chúng ta xem xet một số thuật toán PRAM

a. Thuật toán song song Rút gọn (Parallel Reduction)Cây nhị phân là một trong những cấu trúc quan trong nhất của xử lý song song. Trong nhiều giải thuật trên-xuống (top-down), luồng dữ liệu đi từ nút gốc đến các nút lá của cây. Chẳng hạn như giải thuật phân phát (broadcast) thì nút gốc gửi dữ liệu đến tất cả các nút lá. Giải thuật chia để trị (divide and conquer) thì nút gốc biểu diễn bài toán ban đầu, các nút con biểu diễn các bài toán con.Một số thuật toán dưới đi lên (bottom-up), thì luồng dữ liệu đi từ các nút lá đến nút gốc của cây. Đó là giải thuật rút gọn.Bài toán được phát biểu như sau: “cho một tập n số a1, a2,…, an và một phép toán nhị phân kết

hợp , rút gọn là một quá trình tính a1 a2… an”

Tính tống song song là một ví dụ của phép toán rút gọn.Các bộ xử lý trong PRAM thao tác với dữ liệu được lưu trữ trong các thanh ghi toàn cục. Để triển khai thuật toán tính tổng, ta biểu diễn mỗi nút của cây nhị phân là một phần tử của mảng.

Hình 2.4. Tính tổng một mảng

Giả sử các số cần tính tổng được lưu vào một mảng A, kích thước n. Dưới đây là chương trình giả mã:

SUM (EREW PRAM)Đầu vào: Danh sách n>0 phần tử được lưu trong A[0, ...(n-1)]Đầu ra: Tổng các phần tử được lưu trong A[0]Các biến toàn cục: n, A[0, ...(n-1)]Begin

Spawn(P0, P1, …, P[n/2]) For all Pi với (0≤i≤[n/2]) do For j=0 to [logN]-1 do If i mod 2j =0 and 2*i+2j<n then A[2*i]= A[2*i]+ A[2*i+2j] Endif Endfor Endfor

End.

Ta hãy phân tích độ phức tạp của thuật toán này. Thủ tục Spawn có độ phức tạp log(n/2) vì phải kích hoạt n/2 bộ xử lý dùng cho thuật toán. Vòng lặp tuần tự thực hiện logn lần, và mỗi bước lặp có độ phức tạp thời gian là hằng số. Vì vậy, độ phức tạp chung của thuật toán là O(logn).

Hình dưới đây mô tả từng bước của giải thuật qua một ví dụ về tính tổng của một mảng gồm 10 phần tử:

b. Thuật toán song song Tính tổng tiền tố (Prefix Sums)Bài toán Tính tổng tiền tố như sau: “cho một tập gồm n số a1, a2,…, an và một phép toán nhị

phân kết hợp , hãy tính các biểu thức:

a1

a1 a2a1 a2 a3

….

a1 a2… an”

Chẳng hạn, nếu phép toán là phép cộng (+) và đầu vào là mảng số nguyên [3,1,0,4,2], thì tổng tiền tố của mảng là [3,4,4,8,10].Tổng tiền tố được gọi là tiền tố song song và quét (scan). Tổng tiền tố có nhiều ứng dụng trong thực tế. Ví dụ về nén kí tự như sau: giả sử ta có một mảng A gồm n kí tự. Ta muốn nén các kí tự hoa vào các vị trí đầu của mảng mà vẫn giữ nguyên thứ tự. Trình tự tính toán thể hiện trong hình dưới đây:

A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9]

4 3 8 2 9 1 0 5 6 3

7 10 10 5 9

17 15 9

32 9

41

Hình 2.5. Nén các phần tử của mảng là một ứng dụng của Tổng tiền tố.

Bước đầu tiên (bước b) là khởi động một mảng phụ kích thước n gồm các phần tử 0 và 1. Phần tử T[i] = 0 nếu phần tử A[i] là kí tự thường và T[i] = 1 nếu A[i] là kí tự hoa. Tiếp theo (bước c), ta tính tổng tiền tố các phần tử của mảng T. Kết quả ta thu được là A[T[i]] chứa các kí tự hoa.Dưới đây là giả mã của thuật toán song song tính tổng tiền tố.

(a) Mảng A:

A b C D e F g h I

(b) Mảng T:

1 0 1 1 0 1 0 0 1

(c) Mảng T (sau khi tính tổng tiền tố):

1 1 2 3 3 4 4 4 5

(d) Mảng A (sau khi được nén):

A b C D e F g h I

A C D F I

PREFIX.SUM (CREW PRAM)Đầu vào: Danh sách n>0 phần tử được lưu trong A[0, ...(n-1)]Đầu ra: Mỗi phần tử A[i]= A[0]+ A[1]+..+ A[i-1]Các biến toàn cục: n, A[0, ...(n-1)],jBegin

Spawn(P0, P1, …, P[n-1]) For all Pi với (0≤i≤[n-1]) do For j=0 to [log(n)]-1 do If i - 2j ≥ 0 then A[i]= A[i]+ A[i-2j] Endif Endfor Endfor

End.

Độ phức tạp của thuật toán trên tương tự như thuật toán tìm tổng. Thủ tục spawn có độ phức tạp là O(log(n)). Vòng lặp tuần tự thực hiện [log(n)] lần, mỗi lần lặp cần thời gian là hằng số. Vì vậy, độ phức tạp của thuật toán trên là O(log(n)).Dưới đây là minh họa các bước thực hiện của thuật toán đối với một mảng có 10 phần tử:

Hình 2.6.Tổng tiền tố của một mảng gồm 10 phần tử

c. Thuật toán song song Xếp loại danh sách (List Ranking)Xét bài toán tính các tổng hậu tố (suffix sums) của i phần tử cuối cùng trong một danh sách gồm n phần tử với 0 ≤ i ≤ n. Bài toán tìm các tổng hậu tố là một biến thể (variant) của bài toán tìm tổng các tiền tố mà ta đã xét ở trên với mảng được thay thế bởi một danh sách liên kết, và các tổng được tính từ cuối danh sách. Trong trường hợp mỗi phần tử trong danh sách là 0 hoặc 1, và

toán tử kết hợp là phép cộng thì bài toán trở thành bài toán xếp loại danh sách.

Một cách để xác định vị trí danh sách là đếm số liên kết chuyển tiếp giữa các phần tử và liên kết cuối cùng trong danh sách. Như vậy, danh sách gồm n con trỏ, vậy liệu tồn tại một thuật toán duyệt danh sách với thời gian ít hơn O(n).Nếu ta gắn một bộ xử lý với mỗi phần tử trong danh sách và các con trỏ có thể di chuyển một cách song song, khoảng cách tới điểm cuối cùng của danh sách được giảm một nửa bởi lệnh next[i]= next[next[i]].

Hình 2.7.Tìm vị trí của một phần tử trong một danh sách n phần tử

Vì vậy, có thể ta chỉ cần O (log(n)) bước nhảy là đủ để mọi phần tử trong danh sách có thể trỏ tới được phần tử cuối cùng. Nếu một bộ xử lý bổ sung vào biến đếm position[i] để lưu số lần duyệt qua các liên kết. Nhờ vậy, vị trí danh sách sẽ được xác định.Dưới đây là thuật toán PRAM để xác định vị trí của mỗi phần tử trong một danh sách liên kết đơn.

Thủ tục Spawn cần thời gian logn để kích hoạt n bộ xử lý hoạt động. Thời gian thực hiện các lệnh trong vòng lặp là hằng số và được lặp logn lần, nên độ phức tạp của thuật toán song song là O(logn). d. Thuật toán song song trộn hai danh sách đã sắp xếp (Merging Two Sorted Lists)Một thuật toán RAM tối ưu tại một thời điểm tạo ra danh sách trộn gồm một phần tử và cần nhiều nhất là n-1 phép so sánh để trộn hai danh sách gồm n/2 phần tử. Vì vậy, thuật toán RAM trộn hai danh sách đã được sắp xếp thành một danh sách được sắp xếp với độ phức tạp O(n).Một thuật toán PRAM có thể thực hiện công việc trên với độ phức tạp O(logn) bằng cách gán mỗi phần tử trong danh sách cho mỗi bộ xử lý. Mọi bộ xử lý tìm vị trí cho phần tử của nó trong danh sách còn lại bằng cách sử dụng tìm kiếm nhị phân. Do ta đã biết trước chỉ số của các phần tử trên danh sách của nó, vị trí của nó trong danh sách trộn có thể được tính khi chỉ số của nó trên danh sách còn lại được tìm thấy và hai chỉ số được bổ sung. Tất cả các phần tử có thể được chèn vào trong danh sách trộn với thời gian hằng số. Chương trình giả mã dưới đây biểu diễn thuật toán PRAM trộn hai danh sách :Để đơn giản, trong phiên bản này của thuật toán ta giả sử các giá trị của hai danh sách không giao nhau.

LIST.RANKING (CREW PRAM)Đầu vào:Các giá trị trong mảng next biểu diễn một danh sách liên kết.Đầu ra: Giá trị trong mảng position chứa khoảng cách ban đầu của mỗi phần tử

từ cuối danh sách.Các biến toàn cục: n, position[0, ...(n-1)], next [0, ...(n-1)],j

BeginSpawn(P0, P1, …, Pn-1)

For all Pi với (0≤i≤n-1) do If next[i]= i then position[i]=0 else position[i]=1 Endif For j=1 to [log(n)] do position[i]= position[i]+ position[next[i]] next[i]= next[next[i]] Endfor Endfor End.

Trộn hai danh sách đã sắp xếp vào một danh sách

Như thường lệ, các bộ vi xử lý được kích hoạt tại bước đầu tiên của thuật toán. Trong thuật toán này ta cần n bộ xử lý, mỗi bộ xử lý tìm vị trí cho một phần tử tử hai danh dách ban đầu. Sau khi các bộ xử lý được kích hoạt, chúng sẽ xác định khoảng chỉ số mà chúng tìm kiếm một cách song song. Các bộ xử lý gắn với các phần tử trong nửa “thấp” của mảng (nửa chứa các giá trị bé hơn phần tử đang cần tìm vị trí) sẽ được thực hiện tìm kiếm nhị phân trên các phần tử trong nửa “cao” của mảng và ngược lại.

MERGE.LISTS (CREW PRAM)Đầu vào: Hai danh sách gồm n/2 phần tử đã được sắp xếp A[1..(n/2)] và

A[(n/2)+1..n] .Đầu ra: Danh sách A[1..n] đã được sắp xếp, được trộn từ hai danh sách trên.Các biến toàn cục: n, A[1..n]Các biến cục bộ: x, low, high, indexBegin

Spawn(P1, P2, …, Pn) For all Pi với (1≤i≤n) do /*Mỗi bộ xử lý thiết lập biên cho tìm kiếm nhị phân*/ If i ≤ (n/2) then Low = (n/2)+1 High = n else Low = 1 High = (n/2) Endif /*Mỗi bộ xử lý thực hiện tìm kiếm nhị phân*/ x=A[i] Repeat Index=[(low+high)/2] If x ≤ A[index] then High = index-1

else Low = index+1 Endif until low>high /*Đưa giá trị vào đúng vị trí trong danh sách trộn*/ A[High+i-(n/2)]=x EndforEnd

Hình 2.8. Trộn hai mảng đã sắp xếp thành một mảng đã săp xếp

Mỗi bộ xử lý có duy nhất một giá trị x, một phần tử sẽ được trộn. Vòng lặp repeat…until thực hiện tìm kiếm nhị phân. Khi một bộ xử lý thoát khỏi vòng lặp thì biến high sẽ được gán lại giá trị là chỉ số của phần tử lớn nhất trong danh sách chứa các phần tử nhỏ hơn x.Xét một bộ xử lý Pi và giá trị A[i] được gán cho Pi trong nửa “thấp” của danh sách. Giá trị lowcuối cùng phải nằm giữa (n/2) và n. phần tử A[i] lớn hơn i-1 phần tử trong nửa thấp của danh sách. Đồng thời, nó cũng lớn hơn high-(n/2) phần tử trên nửa cao của danh sách. Do vậy, ta sẽ đặt A[i] vào danh sách được sắp xếp sau i+high-(n/2)-1 phần tử khác và nó có chỉ số i+high-(n/2).Trường hợp tiếp theo ta xét bộ xử lý Pi và giá trị A[i] được gán cho Pi trong nửa “cao” của danh sách. Giá trị của biến high phải nằm giữa 0 và (n/2). Phần tử A[i] lớn hơn i-(n/2)-1 phần tử khác trong nửa cao của danh sách và lớn lơn high phần tử trong nửa thấp của danh sách. Do vậy, A[i]sẽ được đặt vào danh sách được sắp xếp sau i+high-(n/2)-1 phần tử khác và nó có chỉ số i+high-(n/2).Do tất cả các bộ xử lý sử dụng cùng một cách tìm vị trí cho các phần tử trong danh sách trộn, nên mọi bộ xử lý cùng sử dụng một phép gán khi kết thúc thuật toán.Tổng số thao tác được thực hiện để trộn các danh sách tăng từ O(n) trong thuật toán tuần tự lên O(nlogn) trong thuật toán song song. Tuy nhiên, với n bộ xử lý thực hiện song song thì độ phức tạp về thời gian chỉ còn là O(logn). Với giả thiết (cho các thuật toán PRAM) là số bộ xử lý là vô hạn thì thuật toán này hiệu quả đáng kể. Nhưng khi cài đặt thực tế thì số lượng bộ xử lý là có hạn, nên ta phải xem xét chi phí thực tế cho thuật toán.

2.2 Các thuật toán song song nhân hai ma trậnPhần này giới thiệt về các thuật toán song song nhân ma trận được thực hiện cho các mô hình SIMD trên các máy tính song song khác nhau. Thuật toán song song nhân hai ma trận trên máy

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8]

1 5 7 9 13 17 19 23

1 2 4 5 7 8 9 11 12 13 17 19 21 22 23 24

2 4 6 8 10 21 23 24

A[9] A[10] A[11] A[12] A[13] A[14] A[15] A[16]

SIMD với tổ chức bộ vi xử lý theo mạng hình lưới là O(n); Một thuật toán song song được thiết kế cho máy SIMD với các bộ xử lý được tổ chức theo mạng siêu khối và mạng hoán vị di chuyển với độ phức tạp la O(logn).

2.2.1 Thuật toán nhân ma trận tuần tự

Tích của ma trận A kích thước l x m với một ma trận B kích thước m x n là một ma trận C kích thước l x n, mà các phần tử của nó được xác định bởi:

C[i,j] =

1

1

],[*],[m

k

jkBkiA

Một thuật toán tuần tự nhân hai ma trận cấp n có độ phức tạp O(n3) vì nó cần tới n3 phép cộng và n3 phép nhân.

2.2.2 Thuật toán nhân ma trận trên máy SIMD với các bộ xử lý được tổ chức theo mạng hình lưới hai chiều (2-D Mesh SIMD).

Cận dưới của thuật toán: Gentleman đã chỉ ra rằng nhân hai ma trận cấp n x n trên máy tính SIMD với các bộ xử lý được tổ chức theo hình lưới 2 chiều cần không ít hơn Ω(n) bước định tuyến dữ liệu.

Định nghĩa 2.1: Cho một mục dữ liệu ban đầu có sẵn trên một bộ xử lý trong một mô hình tính toán song song nào đó, và p(k) là số lượng lớn nhất các bộ xử lý mà dữ liệu có thể chuyển tới trong k hoặc ít hơn k bước định tuyến dữ liệu (data rounting steps).Chẳng hạn, trong máy tính SIMD với các bộ xử lý được tổ chức theo hình lưới 2 chiều thì p(0)=1, p(1)=5, p(2)=13 và trong trường hợp tổng quát thì p(k)=2k2+2k+1.

MATRIX_ MULTIPLICATION()Đầu vào: Hai ma trận: A[1..m,1..n], B[1..n,1..k].Đầu ra: Ma trận C[1..m, 1..k] là ma trận tích của A và BBegin

For i=1 to m do For j=1 to k do

Begin t=0 for h=1 to n do t=t+A[i,h]*B[h,j] endfor C[i,j]=t End; Endfor Endfor End.

Bổ đề 7.1. Giả sử ta muốn nhân hai ma trận A và B kích thước n x n, và mỗi phần tử của A và B được lưu đúng một lần và không có bộ xử lý nào chứa nhiều hơn một phần tử của ma trận còn lại. Nếu ta bỏ qua sự thuận tiện về truyền thông (broadcasting facility), phép nhân hai ma trận A và B để tạo ra ma trận C yêu cầu ít nhất s bước định tuyến dữ liệu, mà p(2s) ≥ n2.Chứng minh: Xét một phần tử bất kỳ c[i,j] của ma trận tích. Phần tử này là kết quả của tổng các tích của các phần tử của hàng i của ma trận A và cột j của ma trận B. Do vậy, sẽ có một đường đi từ các bộ xử lý lưu các phần tử này tới bộ xử lý chứa kết quả c[i.j]. Gọi s là độ dài đường đi dài nhất như vậy. Nói cách khác, việc tạo ra ma trận C cần ít nhất s bước định tuyến dữ liệu. Chú ý rằng, các đường đi cũng có thể được định nghĩa là một tập hợp các đường đi có độ dài lớn nhất 2s từ bất kỳ phần tử B[u,v] tới mọi phần tử A[i,j] nào đó. Do tồn tại một đường đi với độ dài không vượt quá s đi từ một bộ xử lý chứa phần tử B[u,v] đến bộ xử lý chứa C[i,v] và cũng có một đường đi với độ dài không vượt quá s đi từ A[i,j] đến C[i,v]. Vì vậy, tồn tại một đường đi với độ dài không vượt quá 2s đi từ mỗi phần tử B[u,v] đến A[i,j]. Tương tự như vậy các đường đi này xác định một tập các đường đi với độ dài không vượt quá 2s từ mọi phần tử A[u,v] bất kỳ tới mọi phần tử B[i,j], với mọi 1 ≤ i,j ≤ n; n2 phần tử của ma trận A được lưu trong các bộ xử lý riêng biệt (mỗi bộ xử lý chứa một phần tử). Do tồn tại một đường đi với độ dài không vượt quá 2s đi từ một bộ xử lý chứa B[u,v], tới các bộ xử lý lưu các phần tử của ma trận A, nên theo định nghĩa 2.1 ở trên ta sẽ có p(2s) ≥ n2.

Định lý 7.1. Nhân ma trận trên máy tính SIMD với các bộ xử lý được tổ chức theo hình lưới 2 chiều yêu cầu Ω (n) bước định tuyến dữ liệu, hoặc với n lớn s ≥ 0.35n.Chứng minh: Từ bổ đề 7.1, ta có p(2s) ≥ n2, trên máy tính SIMD với các bộ xử lý được tổ chức theo hình lưới 2 chiều thì ta có p(s)=2s2+2s+1, nên p(2s)=8s2+4s+1, do đó

8s2+4s+1 ≥ n2

s2 + (s/2)+ 1/8 ≥ (n2/8)

(s + 1/4)2 + 1/16 ≥ (n2/8)

s ≥ sqrt(2n2-1)/4 -1/4 ≈ 0.35n. khi n đủ lớn.

Một thuật toán tối ưu, Cho một máy tính SIMD với các bộ xử lý được tổ chức theo hình lưới 2 chiều có kết nối vòng (wrap-around), thì dễ nhận thấy có thể đưa ra một thuật toán sử dụng n2 bộ xử lý để nhân hai ma

trận kích thước n x n với độ phức tạo về thời gian là (n).

Trong thuật toán tuần tự cần n3 phép nhân, và để n2 bộ xử lý có thể hoàn thành tính nhân hai ma

trận trong thời gian (n) thì tất cả n2 bộ xử lý phải cùng thực hiện tính toán ma trận kết quả tại

mỗi bước. Pha khởi tạo cấp phát các phần tử của ma trận cho các bộ vi xử lý, được minh họa trên hình (?). Các bộ xử lý ở dòng i cột j trong mạng hình lưới chứa A[i,j] và B[i,j]. Chú ý rằng, trong bước khởi tạo chỉ có n bộ xử lý chứa một cặp cho phép nhân. Tuy nhiên, nó có thể di chuyển ma trận A và B để mỗi bộ xử lý chứa một cặp phần tử cần được nhân với nhau (hình 2.9). Hơn nữa, mỗi lần quay lên trên của các phần tử trong ma trận B và quay trái các phần tử trong ma trận A sẽ làm cho mỗi bộ xử lý có một cặp phần tử mới để thực hiện phép nhân.

Hình 2.9. Thuật toán nhân ma trận trên máy SIMD tổ chức theo hình lưới 2 chiều

Ở pha sắp xếp các phần tử của thuật toán nhân ma trận trên máy tính SIMD với các bộ xử lý được tổ chức theo hình lưới 2 chiều. (a) Khởi tạo và phân phát các cặp phần tử A[i,j] và B[i,j] cho các bộ vi xử lý, sau đó thuật toán tiến hành nhân tất cả các cặp (A[i,k],B[k,j]) (chú ý rằng chỉ có các bộ xử lý P(0,0), P(1,1), P(2,2) và P(3,3) chứa các cặp như vậy. (b) thuật toán di chuyển mỗi hàng i của ma trận A sang bên trái bởi j vị trí cột. Đồng thời, di chuyển mỗi cột j của ma trận B lên phía trên bởi i vị trí hàng. (c) giống phần (b), sau khi di chuyển vòng quanh (wrap-around), bây giờ mỗi bộ xử lý P(i,j) có một cặp phần tử để nhân.

Ta hãy xem các hành động của một bộ xử lý (hình ..). Sau khi các phần tử của hai ma trận A và B được di chuyển, bộ xử lý P(1,2) thực hiện các phép nhân và cộng để tính C[1,2].

Hình 2.9. Thuật toán nhân ma trận trên máy tính SIMD với các bộ xử lý được tổ chức theo hình lưới

2 chiều từ cách nhìn các bước thực hiện của bộ xử lý P(1,2). Các phần tử của ma trận đã được di

chuyển. (a) là bước đầu tiên. (b) bước thứ hai được thực hiện sau khi các phần tử của được “quay

vòng” sang trái và các phần tử của B được di chuyển lên trên. (c) bước 3 được thực hiện sau bước

(b). (d) được thực hiện sau bước 3, ở bước này bộ xử lý P(1,2) đã tính xong C[1,2].

Pha đầu của thuật toán là phân phát và di chuyển các phần tử của hai ma trận. Pha thứ hai tính tất cả các tích A[i.k]*B[k,j] và tính tổng chúng lại với nhau.

2.2.3 Thuật toán nhân ma trận trên máy SIMD với các bộ xử lý được tổ chức theo mạng hình siêu khối (Hypercube SIMD).

Định lý 2.2: Cho một máy tính SIMD với các bộ vi xử lý được tổ chức theo hình siêu khối với n3=33q bộ xử lý, thuật toán hai ma trận kích thước n x n thực hiện trên máy tính này có độ phức

tạp (logn) (Dekel et al., 1989).

Chứng minh: Ý tưởng chính của giải thuật nằm ở chỗ cải tiến chiến lược định tuyến dữ liệu; chỉcần 5q=5logn bước định tuyến là đủ để phân phát các giá trị dữ liệu ban đầu qua một mảng các bộ xử lý và kết hợp các kết quả.Các bộ xử lý được xem như một lưới (lattice) 3 chiều n x n x n. Bộ xử lý P(x), với 0 ≤ x ≤ 23q-1 có các vị trí a, b, c, s và t trong bộ nhớ cục bộ.

MATRIX_ MULTIPLICATION(2-D MESH SIMD)Đầu vào: Hai ma trận: A[0..l-1,0..m-1], B[0..m-1,0..n-1].Đầu ra: Ma trận C[0..l-1, 0..n-1] là ma trận tích của A và BBiến toàn cục: n,kBiến cục bộ: a,b,cBegin

/*Di chuyển ma trận*/ For k=1 to n-1 do

For all P(i,j) where 1 ≤ i,j ≤ n do If i > k then a = east(a) endif If i > k then b = south(b) endif Endfor Endfor /*tính tích */ For all P(i,j) where 1 ≤ i,j ≤ n do c = a *b Endfor For k=1 to n-1 do

For all P(i,j) where 1 ≤ i,j ≤ n do a = east(a) b = south(b) c = c + a*b endfor Endfor Endfor End.

Khi thuật toán song song bắt đầu thực hiện. Trong suốt pha đầu A[i,j] và B[i,j] với 0 ≤ i,j≤ n-1, được lưu trong các biến a và b của bộ xử lý P(2q*i + j) (xem giả mã). Sau khi thuật toán song song hoàn thành thì ma trận C[i,j] với 0 ≤ i,j≤ n-1, được lưu trong biến c của bộ xử lý P(2q*i + j)Thuật toán có 3 pha. Trong pha đầu, A[i,j] và B[i,j] được phân phát cho các bộ xử lý còn lại. Sau vòng lặp for thứ nhất thì:[22q*k + 2q*i +j] a = A[i,j][22q*k + 2q*i +j] b = B[i,j]Với mọi 0 ≤ k≤ n-1,Sau vòng lặp for thứ hai thì:[22q*k + 2q*i +j] a = A[i,k] với 0 ≤ j≤ n-1

Sau vòng lặp for thứ ba thì:[22q*k + 2q*i +j] a = B[k,j] với 0 ≤ i≤ n-1

Có n3 phép nhân được thực hiện và sử dụng n3 bộ xử lý. Do quá trình phân phát hoàn thành trong pha đầu tiên thì tất cả các tích A[i,k] * B[k,j] có thể được hoàn thành một cách đồng thời trong pha thứ 2. Pha thứ 3 của thuật toán thực hiện việc định tuyến và tính tổng các phép nhân.Có hai hàm mới là BIT và BIT.COMPLEMENT được sử dụng trong thuật toán này. Hàm BIT nhận đầu vào là hai số nguyên m và l, trả lại giá trị là bít thứ l trong biểu diễn nhị phân của m. Hàm BIT.COMPLEMENT nhận đầu vào là hai số nguyên m và l, trả lại giá trị là một số nguyên được sinh ra do phép bù bít thứ l trong biểu diễn nhị phân của m. Dưới đây là các ví dụ về hàm BIT và BIT.COMPLEMENTBIT (9,0)=1 BIT.COMPLEMENT(9,0)=8BIT (9,1)=0 BIT.COMPLEMENT(9,1)=11BIT (9,3)=1 BIT.COMPLEMENT(9,3)=1BIT (9,4)=0 BIT.COMPLEMENT(9,4)=25BIT (9,5)=0 BIT.COMPLEMENT(9,5)=41

Thuật toán song song đầy đủ được trình bày ở dưới đây.Ví dụ minh họa (hình ?) các bước của thuật toán khi thực hiện nhân hai ma trận kích thước 2 x 2 trên một máy tính SIMD với các bộ vi xử lý được tổ chức theo hình siêu khối với 8 bộ xử lý.Vòng lặp for đầu tiên yêu cầu 2q bước định tuyến dữ liệu. Ba vòng lặp cuối yêu cầu q bước định tuyến dữ liệu cho mỗi vòng. Do đó, tổng số cần 5q bước định tuyến dữ liệu là đủ để nhân hai ma trận trên một máy tính SIMD với các bộ vi xử lý được tổ chức theo hình siêu khối. Đồng thời, thuật toán cũng sử dụng 1 bước thực hiện phép nhân và q bước thực hiện phép cộng. Từ đó ta có độ phức tạp của thuật toán song song nhân ma trận thực hiện trên một máy tính SIMD với n3 bộ

xử lý được tổ chức theo hình siêu khối là (q) = (logn).

MATRIX.MULTIPLICATION (Hypercube SIMD)Tham số: q {kích thước ma trận là 2q X 2q}

Biến toàn cục: lBiến cục bộ: a,b,c,s,tBegin

{Pha 1: phân phát các phần tử A[i,j] và B[i,j]}

For l = 3q-1 downto 2q do For all Pm với BIT(m,l)=1 do t = BIT.COMPLEMENT(m,l) a = [t]a b = [t]b endfor endfor

For l = q-1 downto 0 do For all Pm với BIT(m,l) ≠ BIT(m,2q+l) do t = BIT.COMPLEMENT(m,l) a = [t]a endfor endfor

For l = 2q-1 downto q do For all Pm với BIT(m,l) ≠ BIT(m,q+l) do t = BIT.COMPLEMENT(m,l) b = [t]b endfor endfor {Pha 2: thực hiện các phép nhân song song}

For all Pm do c = a x b endfor

{Pha 3: tính tổng}

For l = 2q to 3q-1 do For all Pm do t = BIT.COMPLEMENT(m,l) s = [t] c c= c+s endfor endforEnd.

Một ví dụ:

Hình 2.10. Thuật toán nhân ma trận trên máy SIMD siêu khối

2.2.4 Thuật toán nhân ma trận trên máy đa bộ xử lý.

Bài toán nhân ma trận thể hiện đầy đủ yếu tố song song hóa trên máy tính đa bộ xử lý. Trong thuật toán nhân ma trận tuần tự, ba vòng lặp For có thể song song hóa được. Điều này phát sinh một câu hỏi thú vị: có phải tất cả các vòng lặp (và các vòng lặp lồng nhau (nested loops)) có thể song song hóa được không?.Trước hết, ta tìm hiểu một khái niệm liên quan đến hiệu suất của các hệ thống song song: độ hoàn thành công việc cộng tác (grain size).Độ hoàn thành công việc cộng tác là khối lượng công việc được thực hiện qua sự tương tác (interations) giữa các bộ vi xử lý. Do mục tiêu của ta là giảm các chi phí (overhead) do quá trình song song gây ra, bất cứ khi nào độ hoàn thành công việc cộng tác càng lớn càng tốt.Xét bài toán nhân hai ma trận, ta có thể song song vòng lặp với j hoặc vòng lặp với i mà không bị ảnh hưởng bởi sự phụ thuộc dữ liệu từ vòng lặp trong cùng (innermost loop). Nếu ta song song hóa vòng lặp j, thuật toán song song thực hiện n lần đồng bộ (mỗi lần lặp là một lần đồng bộ), và độ hoàn thành công việc cộng tác của đoạn mã song song là O(n2/p). Nếu ta song song vòng lặp i,

thuật toán song song thực hiện 1 lần đồng bộ, và độ hoàn thành công việc cộng tác của đoạn mã song song là O(n3/p). Đối với máy tính đa bộ xử lý truy cập bộ nhớ đồng bộ (UMAmultiprocessors), thì vòng lặp song song i sẽ thực hiện nhanh hơn. Thuật toán song song nhân ma trận cho máy tính đa xử lý truy cập bộ nhớ đồng bộ được trình bày dưới đây.

Ta hãy tính độ phức tạp của thuật toán trên. Mỗi tiến trình tính n/p hàng của ma trận C. Thời gian

cần thiết để tính một hàng là (n2). Các tiến trình đồng bộ chính xác một lần, chi phí đồng bộ là

(p). Vì vậy độ phức tạp của thuật toán song song này là (n3/p + p). Chú ý rằng, vì chỉ có n

hàng, nên có nhiều nhất n tiến trình có thể được thực hiện trong thuật toán này. Nếu ta bỏ qua khả năng tranh chấp bộ nhớ (memory contention), thì tốc độ (speedup) sẽ tiệm cận đến tuyến tính.Trong thực tế liệu ta có thể bỏ qua thời gian truy cập bộ nhớ?. Điều này có thể được khi thực hiện thuật toán trên máy tính đa bộ xử lý truy cập bộ nhớ đồng bộ. Trên máy tính đa bộ xử lý truy cập bộ nhớ đồng bộ thì khoảng cách của tất cả các ô nhớ trong bộ nhớ toàn cục tới các bộ xử lý là như nhau.Một phương pháp khác có thể cải tiến thuật toán trên là nhân ma trận khối (block matrix multiplication). Giả sử A và B là hai ma trận kích thước n x n với n=2k thì mỗi ma trận A hoặc B được coi như một khối gồm 4 ma trận con kích thước k x k:A = ( A11 A12 ) và B = ( B11 B12 ) A21 A22 B21 B22

Khi đó, ma trận kết quả C sẽ được xác định như sau:C = ( C11 C12 ) = ( A11B11 + A12 B21 A11B12 + A12 B22 ) C21 C22 A21B11 + A22 B21 A21B12 + A22 B22

MATRIX_ MULTIPLICATION(UMA MULTIPROCESSORS)Biến toàn cục:

n, A[0..n-1,0..n-1], B[0..n-1,0..n-1], C[0..n-1,0..n-1] Biến cục bộ: i,j,k,tBegin

For all Pm (1 ≤ m ≤ p) do For i =m to n step p do

for j=1 to n do t=0 for k=1 to n do t=t+A[i,k]*B[k,j] endfor C[i,j]=t Endfor EndforEnd.

Nếu ta gán các process để thực hiện tính các ma trận khối, thì số lượng phép nhân và cộng và đọc dữ liệu từ bộ nhớ trên mỗi ma trận khối sẽ tăng. Chẳng hạn, có p=(n/k)2 tiến trình, thì phép nhân ma trận được thực hiện bởi việc chia A và B thành p khối kích thước k x k. Mỗi khối 2k2 lần đọc bộ nhớ (fetches), k3 phép cộng, và k3 phép nhân. Số các tháo tác tính toán trên một lần truy xuất

bộ nhớ sẽ tăng từ 2, trong thuật toán trước lên k=n/ p trong thuật toán này, đây là một sự cải

tiến đáng kể. Dưới đây là một ví dụ về thuật toán nhân ma trận hướng khối.

Hình 2.11. Ví dụ minh họa thuật toán nhân ma trận khối.

Hình 2.12. Tốc độ của thuật toán nhân ma trận.

2.3 Các thuật toán sắp xếp song song.Sắp xếp là một trong những bài toán cơ bản nhất của khoa học máy tính. Trong nhiều bài toán tìm kiếm thông tin yêu cầu tập dữ liệu phải được sắp xếp trước khi tìm kiếm để tăng hiệu quả tìm kiếm. Sắp xếp có ý nghĩa quan trọng đối với các nhà thiết kế thuật toán song song: nó được sử dụng thường xuyên để thực hiện các phép hoán vị dữ liệu tổng quát trên máy tính với các bộ nhớ phân tán. Các thao tác di chuyển dữ liệu này có thể được sử dụng để giải các bài toán trong lý thuyết đồ thị, hình học giải tích, và xử lý ảnh với thời gian tối ưu hoặc cận tối ưu.Đã có nhiều kết quả trong nghiên cứu phát triển các thuật toán sắp xếp song song mà ta sẽ thảo luận trong các phần sau như: các thuật toán sắp xếp song song trên máy tính bộ xử lý mảng, máy tính đa bộ vi xử lý, và đa máy tính. Tất cả thuật toán này được gọi là sắp xếp trong. Nghĩa là, chúng sắp xếp các mảng có kích thước nhỏ hơn hoặc vừa với bộ nhớ chính. Đồng thời, các thuật toán này sắp xếp bằng cách so sánh từng cặp phần tử.

2.3.1 Sắp xếp bằng liệt kê (enumeration sort) và cận dưới (lower bounds) của sắp xếp song song.

a. Sắp xếp bằng liệt kê:Bài toán được phát biểu như sau: cho một mảng gồm n phần tử a0, a1,.., an-1 với thứ tự đã được xác định. Đối với 2 phần tử ai, aj thì có các trường hợp sau: ai < aj , ai =aj, và ai >aj. Mục tiêu của sắp xếp là tìm một hoán vị (t0, t1,…, tn-1) sao cho at0 ≤ a t1,.., ≤ a tn-1

Dưới đây là thuật toán sắp xếp theo liệt kê:

Một tập gồm n phần tử có thể được sắp xếp trong thời gian (logn) với n2 bộ xử lý trên một máy

tính mô hình PRAM CRCW trong đó ghi đồng thời vào cùng một vị trí làm cho tổng các giá trị được gán. Nếu thời gian kích hoạt các bộ xử lý không tính đến thì thời gian thực hiện thuật toán là hằng số.

b. Cận dưới của sắp xếp song song:Ở trên ta đã chỉ ra rằng sắp xếp có thể được thực hiện trong thời gian là hằng số nếu có đủ bộ xử lý và một mô hình tính toán song song đủ mạnh (như một phiên bản của PRAM). Vậy cận dưới để sắp xếp song song trên một mô hình tính toán song song hợp lý là gì?. Trong phần này ta đi tìm cận dưới của các thuật toán sắp xếp song song dựa trên máy tính với các bộ xử lý được tổ chức theo mạng hình lưới 1 chiều, 2 chiều và mạng hoán vị-di chuyển.

Định lý 2.3-1: Giả sử ta cần sắp xếp n phần tử trên một máy tính mảng các bộ xử lý được tổ chức như một mạng hình lưới 1 chiều. Và giả sử rằng trước và sau khi sắp xếp các phần tử được phân phát đều (evenly distributed) với mỗi phần tử trên một bộ xử lý. Thì cận dưới của độ phức tạp về

thời gian là (n).

Chứng minh: Độ rộng phân đôi của một mạng hình lưới một chiều với n nút là 1. Giả sử rằng, các vị trí được sắp xếp của tất cả các phần tử ban đầu trên một bên của mạng phân đôi (bisection). Thì tất cả n phần tử phải đi qua 1 liên kết để sang nửa bên kia. Do tại một thời điểm một liên kết chỉ có thể chứa một phần tử, số bước cần để đổi chỗ (swap) các phần tử qua hai nửa của mạng ít nhất là n. Vì vậy, cận dưới của độ phức tạp của bất kỳ thuật toán sắp xếp nào được thực hiện trên máy

tính với các bộ xử lý được tổ chức theo một mạng hình lưới 1 chiều là (n).

Định lý 2.3-2: Giả sử ta cần sắp xếp n phần tử trên một máy tính mảng các bộ xử lý được tổ chức như một mạng hình lưới 2 chiều. Và giả sử rằng trước và sau khi sắp xếp các phần tử được phân phát đều (evenly distributed) với mỗi phần tử trên một bộ xử lý. Thì cận dưới của độ phức tạp về

thời gian là ( n ).

ENUMERATION SORT(SPECIAL CRCW PRAM)Tham số: nBiến toàn cục: A[0.. n-1], Position[0..n-1], Sorted[0..n-1] .Begin

Spawn(Pi,j for all 0 ≤ i,j ≤ n-1) For all Pi,j where 0 ≤ i,j ≤ n-1 do Position[i]=0

If a[i] < a[j] or (a[i] =a[j] and i <j) then Position[i]=0 endif endfor For all Pi,0 where 0 ≤ i ≤ n-1 do Sorted[Position[i]] = A[i] endforEnd;

Chứng minh: Độ rộng phân đôi của một mạng hình lưới 2 chiều với n nút không vượt quá n .

Giả sử rằng, các vị trí được sắp xếp của tất cả các phần tử ban đầu trên một bên của mạng phân

đôi (bisection). Thì tất cả n phần tử phải đi qua 1 hoặc không nhiều hơn n liên kết để sang nửa

bên kia. Do tại một thời điểm một liên kết chỉ có thể chứa một phần tử, số bước cần để đổi chỗ

(swap) các phần tử qua hai nửa của mạng ít nhất là n/ n . Vì vậy, cận dưới của độ phức tạp của

bất kỳ thuật toán sắp xếp nào được thực hiện trên máy tính với các bộ xử lý được tổ chức theo

một mạng hình lưới 2 chiều là (n/ n )= ( n ).

Định lý 2.3-3: Giả sử ta cần sắp xếp n = 2k phần tử trên một máy tính mảng các bộ xử lý được tổ chức theo một mạng hoán vị-di chuyển . Và giả sử rằng trước và sau khi sắp xếp các phần tử được phân phát đều (evenly distributed) với mỗi phần tử trên một bộ xử lý. Thì cận dưới của độ

phức tạp về thời gian là (logn).

Chứng minh: Giả sử vị trí đã được sắp xếp của một phần tử ban đầu ở nút 0 là nút n-1. Chuyển phần tử đó từ nút 0 đến nút n-1 cần ít nhất logn thao tác hoán vị và ít nhất logn-1 thao tác di chuyển. Vì vậy cận dưới bất ký thuật toán sắp xếp nào dựa trên mạng hoán vị di chuyển cũng có

độ phức tạp không vượt quá (logn).

2.3.2 Sắp xếp song song đổi chỗ chẵn lẻ (odd-even transposition) .

Sắp xếp đổi chỗ chẵn lẻ được thiết kế cho máy tính mảng các bộ xử lý trong đó các bộ xử lý được tổ chức trong một mạng hình lưới 1 chiều.Giả sử rằng A=( a0, a1,.., an-1) là một tập n phần tử cần được sắp xếp, với n là số chẵn. Mỗi bộ xử lý có hai biến cục bộ t và a, trong đó a là một phần tử của mảng A và t là biến chứa giá trị được lấy từ bộ xử lý bên cạnh.Thuật toán thực hiện n/2 lần lặp, mỗi lần lặp gồm hai pha:Pha đầu được gọi là đổi chỗ lẻ chẵn (odd-even exchange), giá trị a trên mỗi bộ xử lý có số hiệu lẻ (trừ bộ xử lý thứ n-1) được so sánh và hoán vị (nếu cần) với giá trị nằm trên bộ xử lý kế tiếp. Do vậy bộ xử lý có số hiệu nhỏ sẽ lưu giá trị nhỏ hơn. Pha thứ hai được gọi là đổi chỗ chẵn lẻ, trong đó giá trị a trong mỗi bộ xử lý có số hiệu chẵn được so sánh và hoan vị (nếu cần) với giá trị đang được lưu ở bộ xử lý kế tiếp và do đó bộ xử lý có số hiệu nhỏ sẽ lưu giá trị nhỏ hơn. Sau n/2 lần lặp thì tất cả các giá trị sẽ được sắp xếp.

Ví dụ về thuật toán song song hoán vị chẵn lẻ:

Chỉ số 0 1 2 3 4 5 6 7

Mảng ban đầu G H F D E C B A

Sauk hi hoán vị lẻ chẵn G F < H D < E B < C A

Sau khi hoán vị chẵn lẻ F < G D < H B < E A < C

Sau khi hoán vị lẻ chẵn F D < G B < H A < E C

Sau khi hoán vị chẵn lẻ D < F B < G A < H C < E

Sau khi hoán vị lẻ chẵn D B < F A < G C < H E

Sau khi hoán vị chẵn lẻ B < D A < F C G E < H

Sau khi hoán vị lẻ chẵn B A < D C < F E < G H

Sau khi hoán vị lchẵn lẻ A < B C < D E < F G < H

Định lý 2.3-4: Độ phức tạp của thuật toán sắp xếp n phần tử trên máy tính mảng các bộ xử lý trong đó các bộ xử lý được tổ chức trong một mạng hình lưới 1 chiều sử dụng sắp xếp hoán vị

chẵn lẻ là (n).

Chứng minh: Chứng minh dựa trên một thực tế là với i lần lặp bên ngoài của vòng lặp for, không phần tử nào di chuyển quá n-2i vị trí so với vị trí cuối cùng (vị trí đã được sắp xếp). Do vậy n/2

lần lặp là đủ để sắp xếp các phần tử và độ phức tạp về thời gian là (n) với n bộ vi xử lý.

ODD-EVEN TRANSPOSITION SORT(ONE DIMENTIONAL MESH)Tham số: nBiến toàn cục: i.Biến cục bộ: a {phần tử cần sắp}

t {phần tử lấy từ bộ xử lý bên cạnh} Begin

Spawn(Pi for all 0 ≤ i, ≤ n-1) For i=1 to n/2 do For all Pi where 0 ≤ i ≤ n-1 do If j<n and odd(j) then /*hoán vị lẻ chẵn*/ t = successor(a) successor(a) = max (a,t) a = min(a,t) endif If even(j) then /*hoán vị chẵn lẻ*/ t = successor(a) successor(a) = max (a,t) a = min(a,t) endif endfor endfor End.

Từ định lý 2.3-1 thì thuật toán sắp xếp hoán vị chẵn lẻ là một thuật toán tối ưu.

2.3.3 Sắp xếp song song trộn bitonic (bitonic merge)

Thuật toán sắp xếp song song trộn Bitonic (được đề xuất bởi Batcher,1968) là thuật toán có độ phức tạp O(log2n). Trước hết, ta tìm hiểu một số khái niêm sẽ sử dụng trong thuật toán.a. Các mạng so sánh (comparation networks)Các mạng sắp xếp (sorting networks) là các mạng so sánh mà chúng luôn so sánh các đầu vào của chúng. Một mạng so sánh bao gồm các dây dẫn (wires) và các bộ so sánh. Một bộ so sánh (comparator) là một thiết bị gồm 2 đầu vào a và b, và 2 đầu ra a’và b’, thực hiện như sau:a’ = min (x,y)b’ = max(x,y)So sánh- đổi chỗ (compare-exchange) là hai giá trị đầu vào của bộ so sánh có thể đổi chỗ nếu cần thiết để chúng có thứ tự đúng.Nếu kể cả thứ tự của đầu ra thì ta có hai loại bộ so sánh: bộ so sánh từ bé đến lớn (low-to-high) và bộ so sánh từ lớn đến bé (high-to-low). Hình dưới minh họa hai bộ so sánh trên:

Hình 2.13. a Bộ so sánh nhỏ đến lớn; b. Bộ so sánh lớn đến bé.

Thời gian thực hiện thao tác so sánh (tính a’ và b’) là hằng số. Một dây dẫn có thể truyền một giá trị từ nơi này đến nơi khác. Các dây dẫn có thể kết nối đầu ra của bộ so sánh này với đầu vào của bộ so sánh khác. Một mạng sắp xếp gồm n dây dẫn chứa n giá trị đầu vào cần được sắp xếp (a1, a2, ..,an), và n dây dẫn đầu ra (b1, b2, ..,bn) là kết quả của việc sắp xếp n đầu vào.Hình dưới đây là một minh họa về một mạng so sánh.

Mạng so sánh này gồm 4 dây dẫn chứa 4 đầu vào và 5 bộ so sánh A, B, C, D và E.b. Dãy bitomic (bitonic sequence)Một dãy bitonic là một dãy a1, a2, ..,an sao cho:1) tồn tại một chỉ số i với 1 ≤ i ≤ n sao cho dãy con a1, a2, ..,ai là dãy đơn điệu tăng và dãy con ai, ..,an là dãy đơn điệu giảm, hoặc:2) sau một số bước thực hiện phép quay (trái hoặc phải) thì 1) thỏa mãn.Nếu nhìn đồ thị của một dãy bitonic thì nó sẽ gồm một điểm cao nhất (peak) và một điểm thấp nhất (valley).Dưới đây là một vài ví dụ về dãy bitonic:

Hình 2.14. Ba dãy đầu tiên là các dãy bitonic, dãy cuối cùng không phải là bitonic.

Các dãy: (1,4,6,8,3,2), (6,9,4,2,3,5) và (9,8,3,2,4,6) là các dãy bitonic.

Một bước so sánh- đổi chỗ (compare-exchange) có thể chia một dãy bitonic thành hai dãy bitonic như bổ đề 2.3 dưới đây:Bổ đề 2.3: Nếu n là chẵn, thì n/2 bộ so sánh là đủ để chuyển một dãy bitonic gồm n phần tử a1, a2, ..,an thành hai dãy bitonic với mỗi dãy có n/2 phần tử: min(a1, an/2+1), min(a2, an/2+2) …, min(an/2, an) và max(a1, an/2+1), max (a2, an/2+2) …, max (an/2, an) sao cho không có phần tử nào trong dãy đầu tiên lớn hơn bất kỳ phần tử nào trong dãy thứ 2.Chứng minh: Hình (a) dưới đây là một dãy bitonic trước khi được chia đôi.

Hình 2.15. (a). dãy bitonic ban đầu; (b) dãy có nửa đầu và nửa cuối giao nhau; (c). các giá trị bé

nhất; (d). các giá trị lớn nhất; (e). Dãy đã được biến đổi thành 2 dãy bitonic.

Một dãy bitonic có thể được phân chia để trở thành hai dãy con. Theo định nghĩa, dãy ban đầu có nhiều nhất một điểm cao nhất và một điểm thấp nhất. Ta sẽ sử

dụng n/2 bộ so sánh để so sánh mọi phần tử ở nửa đầu của dãy với phần tử tương ứng của dãy thứ 2. Ta sẽ chứng minh bằng phản chứng để chỉ ra rằng không có phần tử nào trong nửa đầu tiên của dãy lớn hơn phần tử bất kỳ trong nửa còn lại. Nếu tồn tại một phần tử trong nửa đầu tiên của dãy lớn hơn một phần tử nào đó trong nửa còn lại thì giá trị nhỏ nhất được trả về từ một bộ so sánh sẽ lớn hơn một giá trị lớn nhất trả về từ một bộ so sánh khác. Nếu điều này đúng, thì dãy không giao nhau ban đầu sẽ chứa hai đỉnh cao nhất (peak) và hai “đáy” thấp nhất (valley) và dẫn tới dãy ban đầu không phải là dãy bitonic, và dẫn tới mâu thuẫn. Mâu thuẫn cho ta kết luận “không có phần tử nào trong nửa đầu tiên của dãy lớn hơn phần tử bất kỳ trong nửa còn lại” là đúng.

Hình 2.15. Minh họa chứng minh bổ đề.

Cho một dãy bitonic, một bước so sánh và đổi chỗ (compare-exchange step) sẽ chia đôi dãy thành 2 nửa dãy bitonic có độ dài bằng nhau..

Hình 2.16. Dạng đệ qui tự nhiên của sắp xếp trộn bitonic.

Áp dụng bước này một cách đệ qui sẽ sinh ra dãy được sắp xếp. Nói cách khác, cho trước một dãy bitonic với n=2k phần tử với k>0 thì cần k bước so sánh và đổi chỗ để sắp xếp dãy bitonic ban đầu.Định lý: Một dãy gồm n=2k phần tử chưa được sắp xếp có thể được sắp xếp bằng cách sử dụng

một mạng so sánh gồm 2k-2k(k+1) bộ so sánh với độ phức tạp (log2n) (Batcher, 1968).

Chứng minh: Sắp xếp trộn bitonic nhận đầu vào là một dãy bitonic và biến đổi nó thành một dãy được sắp xếp. Dãy sắp xếp có thể được xem như một nửa của dãy bitonic. Nếu một dãy bitonic có độ dài 2m được sắp xếp theo thứ tự tăng dần, trong khi đó dãy liền kề với độ dài 2m được sắp xếp theo thứ tự giảm dần, thì sau m bước so sánh và đổi chỗ sẽ kết hợp chúng thành dãy 2m+1 bitonic.

Một dãy gồm n phần tử cần sắp xếp có thể được xem như n dãy còn độ dài 1 hay n/2 dãy bitonic độ dài 2. Vì vậy, ta có thể săp xếp dãy bất kỳ bằng việc trộn liên tiếp chúng để trở thành các dãybitonic có độ dài lớn hơn. Cho một mảng n=2k phần tử chưa được sắp xếp, và một mạng so sánh với k(k+1)/2 mức. Mỗi mức chứa n/2= 2k-1 bộ so sánh. Thì tổng số cần 2k-1 * k(k+1)/2 = 2k-2k(k+1) bộ so sánh. Nếu thực hiện song song thì mỗi mức cần thời gian là hằng số. Tổng số

mức là k(k+1)/2 =logn(logn+1) /2 nên thuật toán có độ phức tạp (log2n).

Hình 2.17. Cần 7 bước so sánh và đổi chỗ để sắp xếp trộn một dãy bitonic 128 phần tử.

Dưới đây là một ví dụ minh họa về một dãy các thao tác trộn bitonic để sắp xếp một danh sách gồm 16 phần tử.

Hình 2.18. Sắp xếp trộn bitonic cho một dãy bitonic gồm 16 phần tử (theo thuật toán Batcher) .

Mỗi mức đồ thị biểu diễn một bước của quá trình sắp xếp. Các phần tử chưa được sắp xếp ở mức đầu tiên. Sau logn lần lặp thì toàn bộ n phần tử đã được sắp xếp. Trong trường hợp này, n=128 và logn=7. Hình dưới minh họa chi tiết quá trình này:

Hình 2.19. Quá trình sắp xếp 128 phần tử qua 7 bước lặp so sánh và đổi chỗ.

Trong hình 2.19, sau bước thứ 7, toàn bộ 128 phần tử được biến đổi thành một dãy bitonic, và logn lần trộn từ các dãy bitonic con để hoàn thành việc sắp xếp.Hình dưới đây minh họa thêm một ví dụ nữa về sắp xếp trộn bitonic sử dụng các bộ so sánh bé-đến-lớn hoặc bộ so sánh lớn-đến-bé.

Hình 2.20. Sắp xếp trộn bitonic trên một dãy gồm 8 phần tử.

c. Sắp xếp trộn bitonic trên mạng di chuyển hoán vị (Shuffle-Exchange) Định lý 2.3: Một dãy chưa được sắp xếp gồm n=2k phần tử có thể được sắp xếp trong thời gian

(log2n) với một mạng 2k-1 [k(k-1)+1] bộ so sánh trên mạng di chuyển hoán vị (Stone, 1971).

Stone nhận thấy rằng bộ sắp xếp của Batcher luôn luôn so sánh các phần tử với chỉ số khác nhau chính xác một bit trong biểu diến nhị phân của chúng. Ta nhớ lại rằng một mạng di chuyển hoàn hảo (perfect shuffle) định tuyến phần tử ở vị trí i tới vị trí được tìm thấy bởi quay trái một bít trong biểu biểu diễn nhị phân của i. Vì vậy, hai chỉ số với biểu diễn nhị phân khác nhau chính xác một bít có thể di chuyển đến đầu vào của cùng một bộ so sánh bằng việc thực hiện một số bước di chuyển.Hình dưới đây minh họa trộn bitonic thực hiện trên mạng di chuyển hoán vị.

Hình 2.21. Sắp xếp dãy bitonic gồm 16 phần tử trên mạng di chuyển hoán vị (theo thuật toán Stone)

Khác với thuật toán Batcher, các kết nối của thuật toán Stone đa dang và biến đổi theo từng bước. Một sắp xếp toàn bộ sẽ được hoàn thành với các liên kết di chuyển hoán vị.Cả hai giải thuật đều cần tới k bước để sắp xếp 2k phần tử, nhưng trong bước thứ i của thuật toán Batcher ở trên cần i bước, cho tổng số k(k+1)/2 bước. Thuật toán Stone cần k(k-1)+1 bước. Để sắp xếp một dãy gồm 8 phần tử thì cần thêm một thao tác ở lần lặp thứ hai xem hình (10-14).

Hình 2.22. Sắp xếp trộn bitonic cho 8 phần tử trên mạng di chuyển hoán vị.

Một số biến thể của mạng di chuyển hoán vị như mạng di chuyển hoàn hảo của Sedgewick, trong đó các kết nối giữa các bộ so sánh giống nhau trên tất cả các bước. Chỉ cần một tầng chứa các bộ so sánh là đủ để sáp xếp như hình dưới đây:

Hình 2.23. Một máy sắp xếp dựa trên mạng kết nối di chuyển hoàn hảo.

Giải thuật song song sắp xếp bitonic của Batcher được trình bày dưới dạng giả mã như sau:

Một vấn đề mà thuật toán phải giải quyết là xác định cặp phần tử cần so sánh sẽ được sắp xếp từ bé đến lớn hay từ lớn đến bé. Thuật toán Stone sử dụng một véc tơ mặt nạ M để kiểu sắp xếp được thực hiện bởi từng phần tử xử lý. Giá trị 0 tương ứng với bộ so sánh (+) (từ bé đến lớn) và giá trị 1 tương ứng với bộ so sánh (-) (từ lớn đến bé).Dưới đây là thủ tục COMPARE-EXCHANGE(a,m)

BITONIC-MERGE SORT(SHUFFLE-EXCHANGE PROCESSOR ARRAY)Tham số: nBiến toàn cục: j,kBiến cục bộ: a {phần tử cần sắp}

m,r {bit mặt nạ và bít được dùng để tính bít mặt lạ } Begin

{Tính giá trị của mặt nạ M} For all Pi where 0 ≤ i ≤ n-1 do r = i mod 2 m = r endfor For i=1 to logn do

For all Pi where 0 ≤ i ≤ n-1 do

m = m r {exclusive OR}

shuffle(m) = m endfor endfor {sắp xếp} COMPARE-EXCHANGE(a,m) For k=1 to logn -1 do For all Pi where 0 ≤ i ≤ n-1 do shuffle(r) = r

m = m r {exclusive OR}

For j=1 to logn – k-1 do shuffle(a) = a shuffle(m) = m

endfor endfor For j=logn-k to logn do For all Pi where 0 ≤ i ≤ n-1 do shuffle(a) = a shuffle(m) = m

endfor COMPARE-EXCHANGE(a,m) endfor endfor end.

Thuật toán này cần logn (logn +1) /2 bước so sánh hoán vị và logn (logn-1) bước di chuyển của véc tơ A, và 2 logn-1 bước di chuyển của véc tơ M và R. Độ phức tạp của thuật toán là O(log2n).

d. Sắp xếp trộn bitonic trên mạng hình lưới 2 chiều (2-D Mesh network)Định lý: Tồn tại một thuật toán sắp xếp n = m2 = 2k phần tử trên máy tính mảng các bộ xử lý được

tổ chức theo mạng hình lưới hai chiều có độ phức tạp ( n ).

Chứng minh: Ta có thể sử dụng một biến thể của thuật toán trộn bitonic của Batcher đã được trình bày ở phần trên thực hiện trên máy tính mảng các bộ xử lý được tổ chức theo mạng hình lưới hai chiều. Với n = 2k phần tử, sắp xếp trộn bitonic gồm k lần lặp, lần lặp thứ i có i bước so sánh- đổi chỗ. Mỗi bước so sánh- đổi chỗ cần hai lần định tuyến dữ liệu: lần định tuyến thứ nhất là mang hai phần tử so sánh với nhau, và lần định tuyến thứ hai là phân phát chúng đúng vị trí.Dưới đây là hình ảnh minh họa thuật toán sắp xếp trộn bitonic với 16 phần tử trên máy tính mảng các bộ xử lý được tổ chức theo mạng hình lưới hai chiều (đề xuất bởi Knuth, 1973).

COMPARE-EXCHANGE(a,m)Tham số: a {phần tử của dãy cần sắp xếp}

m {bít mặt nạ chỉ thứ tự sắp xếp } t {giá trị lấy từ bộ xử lý kế tiếp} Begin

For all Pi,j where 0 ≤ i,j ≤ n-1 do If even(i) then t = exchange (a) If m=0 then Exchange(a) = max (a,t) a = min (a,t) else Exchange(a) = max (a,t) a = min (a,t) endif endif endforEnd.

Hình 2.24. Mạng sắp xếp trộn bitonic với 16 phần tử trên máy tính mảng các bộ xử lý được tổ chức

theo mạng hình lưới hai chiều.

Các mũi tên thể hiện các bộ so sánh- đổi chỗ. Để thực hiện một lần so sánh- đổi chỗ, phần tử ở vị trí đầu và đuôi của mũi tên sẽ được so sánh, phần tử nhỏ hơn sẽ được đưa lên đầu mũi tên và phần tử lớn sẽ được đưa đến đuôi của mũi tên.Chú ý rằng các phần tử ở các vị trí chỉ khác nhau ở một bít có trọng số nhỏ nhất và chúng được so sánh trong mỗi lần lặp. Ở vòng lặp cuối, các phần tử với trọng số bít lớn nhất khác nhau sẽ được so sánh. Thuật toán hiệu quả nhất khi: bít i có trọng số nhỏ hơn bít j, một bước so sánh- đổi chỗ đối với phần tử chứa bít i yếu cầu dữ liệu ít di chuyển hơn đối với phần tử chứa bít j. Một cách để thỏa mãn điều kiện này là sử dụng cách di chuyển hàng là chính (shuffled row-major addressing schema). Hình dưới minh họa một mạng hình lưới 4 x 4 có sử dụng các thao tác di chuyển trên hình vuông con của mạng hình lưới. Điều này làm giảm đi các thao tác di chuyển giữa các bộ xử lý.

Hình 2.25. Các hàm ánh xạ các phần tử cần sắp xếp vào mạng hình lưới 2 chiều.

Hướng di chuyển của tại mỗi bước so sánh- trao đổi phụ thược vào chỉ số của từng bộ xử lý. Hình dưới đây mô tả sắp xếp 16 phần tử trên mạng hình lưới kích thước 4 x 4. Trong trường hợp tổng quát, để sắp xếp n=m2=2k phần tử bằng thuật toán này cần logn pha.

Hình 2.26 Các bước ánh xạ các phần tử cần sắp xếp vào mạng hình lưới 2 chiều.

Tổng số các thao tác di chuyển cần:

Kết quả trên bằng ( n ). Tổng số các bước so sánh là

n

i

ilog

1

= (log2n)

Vì vậy, trong trường hợp xấu nhất, sắp xếp trộn bitonic có độ phức tạp ( n ).

d. Sắp xếp trộn bitonic trên mạng siêu khối (Hypercube) Sắp xếp trộn bitonic luôn luôn so sánh mà các chỉ số khác nhau đúng một bít. Ta nhớ lại rằng trong mạng siêu khối thì các bộ vi xử lý có chỉ số khác nhau đúng một bít được kết nối với nhau. Chính vì vậy, ta có thể dễ dàng trộn bitonic trên mô hình này với các bộ vi xử lý thay thế các bộ so sánh. Thay vì từng cặp phần tử thao tác trên các bộ so sánh, các bộ xử lý cạnh nhau sẽ so sánh và trao đổi dữ liệu cho nhau.Dưới đây là giả mã của thuật toán sắp xếp n= 2m phần tử trên mạng siêu khối.

Độ phức tạp của thuật toán là (m2) = (log2n) với n=2m bộ xử lý.

2.3.4 Sắp xếp song song tựa trên Quicksort

Quicksort là giải thuật sắp xếp đệ qui dựa trên cách tiếp cận chia để trị (divide and conquer).Quicksort thực hiện các bước lặp chia một mảng thành hai mảng nhỏ hơn và một phần tử khóa (medium). Trong đó, một mảng con chứa các phần tử bé hơn (hoặc bằng) phần tử khóa, mảng con còn lại chứa các phần tử lớn hơn (hoặc bằng) phần tử khóa. Phần tử khóa được đặt đúng vị trí. Quá trình này được tiếp tục một cách đệ qui. Phần này giới thiệu về hai giải thuật song song dựa trên giải thuật sắp xếp Quicksort đó là Quicksort song song (Parallel Quicksort) và Siêu Quicksort (HyperQuicksort).

a. Thuật toán Quicksort song song (Parallel Quicksort).Để ý rằng trong giải thuật Quicksort tuần tự thì sau khi phân hoạch thành hai mảng con, thì hai mảng con này có thể được sắp xếp độc lập với nhau.Giả sử ta có một số tiến trình, mỗi tiến trình được thực hiện trên bộ xử lý, để thực hiện giải thuật song song. Các phần tử cần sắp xếp được lưu vào một mảng chứa trong bộ nhớ toán cục. Một ngăn xếp trong bộ nhớ toàn cục để chứa các con trỏ trái và phải của mảng con chưa được sắp xếp. Khi một tiến trình rảnh rỗi, nó sẽ lấy các giá trị con trỏ trái và phải của mảng con khỏi ngăn xếp

BITONIC MERGE SORT(HYPERCUBE PROCESSOR ARRAY)

Biến toàn cục: d {khoảng cách giữa các phần tử cần so sánh}Biến cục bộ: a {một trong các phần tử cần sắp xếp }

t {giá trị lấy từ bộ xử lý kế tiếp} Begin

For i = 0 to m-1 do For j = i downto 1 do

d = 2j

For all Pk where 0 ≤ k ≤ 2m-1 do If k mod 2d < d then t = [k+d]a {lấy giá trị từ bộ xử lý liền kề} if k mod 2i+2 <2i+1 then [k+d]a = max (t,a) {sắp xếp từ bé đến lớn} a = min (a,t) else [k+d]a = min (t,a) {sắp xếp từ lớn đến bé} a = max (a,t) endif endif endfor endfor endfor End.

trong bộ nhớ toàn cục. Nếu thành công, bộ xử lý sẽ chia đôi mảng thành hai mảng con (kích thước mỗi mảng con phụ thuộc vào giá trị của phần tử khóa). Trong đó, có một mảng con chứa các giá trị nhỏ hơn (hoặc bằng) phần tử khóa và mảng con còn lại chứa các phần tử lớn hơn (hoặc bằng) phần tử khóa.Sau khi phân hoạch (giống như phân hoạch trong thuật toán tuần tự), tiến trình sẽ đặt giá trị con trỏ trái và phải của một mảng con vào ngăn xếp trong bộ nhớ toàn cục và lặp lại quá trình phân hoạch cho mảng con còn lại.

Hàm Stack.init() khởi tạo ngăn xếp chứa các con trỏ trái và phải của mảng ban đầu chưa được sắp xếp. Các hàm Stack.Push() và Stack.Pop() đặt vào và lấy ra các giá trị con trỏ trái và phải của mảng con trên đỉnh ngăn xếp.Về độ phức tạp của thuật toán : trong trường hợp xấu nhất thì sau khi phân hoạch, một mảng con rỗng và mảng còn lại gồm n-1 phần tử, cần đến n-min lần phân hoạch để phân hoạch xong mảng.Chính vì điều này làm cho Quicksort song song có cùng độ phức tạp với Quicksort tuần tự là O (n2). Tuy nhiên, người ta đã chứng minh và thử nghiệm được rằng tôc độ (speedup) của Quicksort

PARALLEL QUICKSORT()Biến toàn cục: n {kích thước của mảng}

A[0,..,n-1] {mảng cần sắp xếp} sorted {số phần tử tại vị trí đã được sắp xếp} min, partition {mảng con nhỏ nhất được phân hoạch} Biến cục bộ: bounds {con trỏ trái và phải của mảng chưa được sắp xếp}

median {chỉ số của giá trị khóa} Begin

Sorted = 0 Stack.Init() For all Pi where 0 ≤ i < p do bounds =Stack.pop() while (bounds.low <bounds.high) do if (bounds.high - bounds.low < min.partition) then InsertionSort (A, bounds.low, bounds.high) AddToSorted(bounds.high - bounds.low+1) exit while else median = Partition(bounds.low, bounds.high) Stack.Push (median+1, bounds.high) bounds.high = median -1 if bounds.low = bounds.high then AddToSort(1) endif endif endwhile endforEnd.

song song tốt hơn so với Quicksort tuần tự (việc chứng minh cụ thể khá phức tạp, xin được không nêu ở đây).

b. Thuật toán Siêu Quicksort (HyperQuicksort).Thuật toán Quicksort song song ở trên làm tăng tốc độ xử lý nhờ việc sử dụng nhiều tiến trình được thực hiện đồng thời trên nhiều bộ vi xử lý khác nhau. Ngoài ra, có một số biến thể của Quicksort song song được phát triển để tăng số lượng các bộ vi xử lý làm việc đồng thời. Ở đây, ta giới thiệu một trong số giải thuật đó được thực hiện trên máy tính song song với các bộ vi xử lý được tổ chức theo hình siêu khối: thuật toán Siêu Quicksort được trình bày dưới đây.Cho một dãy các phần tử được phân phối đều (evenly distributed) cho các bộ vi xử lý, ta định nghĩa một dãy được sắp xếp khi:(1). Mọi dãy con trên các bộ xử lý được sắp xếp và(2). Phần tử cuối cùng của dãy con trên bộ xử lý Pi nhỏ hơn hoặc bằng phần tử đầu tiên của dãy con trên bộ xử lý Pi+1 với mọi 0 ≤ i ≤ p-2 . Các phần tử đã được sắp xếp không cần phải phân phối đều trên các bộ xử lý.Để phát triển thuật toán, ta áp dụng chiến lược: cho mỗi bộ xử lý giải một bài toán con và sử dụng cách giải tuần tự hiệu quả nhất trên mỗi bộ xử lý, sau đó sử dụng một thuật toán song song có hiệu quả truyền thông tốt để kết hợp các lời giải bài toán con để thu được lời giải của bài toán ban đầu.Trong pha đầu của thuật toán Siêu Quicksort, mỗi bộ xử lý sử dụng giải thuật Quicksort tuần tự để sắp xếp dãy con cục bộ của nó và quá trình này diễn ra đồng thời đối với tất cả các bộ vi xử lý. Khi pha này kết thúc thì điều kiện (1) được thỏa mãn nhưng điều kiện (2) chưa được thỏa mãn.Siêu Quicksort là một giải thuật đệ qui, sử dụng cách tiếp cận chia để trị (divide and conquer) để làm điều kiện (2) được thỏa mãn. Trong mỗi bước của pha 2, một siêu khối được hai siêu khối con (subcubes). Mỗi bộ xử lý gửi các phần tử của mình tới bộ xử lý khác trong một siêu khối con khác, thì mỗi bộ xử lý sẽ trộn các phần tử của dãy con nó giữ với các phần tử của dãy con nó nhận được từ bộ xử lý bên cạnh. Kết quả của thao tác chia và trộn (split and merge) để chia một siêu khối với dãy đã được sắp xếp thành hai siêu khối với 2 dãy con đã được sắp xếp, và giá trị lớn nhất trong siêu khối dưới sẽ bé hơn phần tử nhỏ nhất của siêu khối trên. Sau d bước chia và trộn, thì từ một mạng siệu khối với 2d bộ xử lý sẽ được chia thành 2d siêu khối con với mỗi siêu khối là một bộ xử lý, và điều kiện (2) được thỏa mãn.Bước chia và trộn chia một siêu khối d chiều thành hai siêu khối d-1 chiều. Để ý rằng các phần tử trên mỗi bộ xử lý đã được sắp xếp. Bộ xử lý được chỉ định trong siêu khối d chiều sẽ phân phát (broadcast) giá trị khóa (median value) tới 2d-1 bộ xử lý khác trong siêu khối. Mỗi bộ xử lý sẽ sử dụng giá trị này để chia dãy con mà nó đang chứa thành hai nửa con sao cho các phần tử của nửadưới nhỏ hơn hoặc bằng giá trị khóa và các phần tử thuộc nửa trên lớn hơn giá trị khóa. Mỗi bộ xử lý Pi trong nửa dưới của siêu khối sẽ gửi nửa dãy con trên (nửa chứa các phần tử lớn hơn giá

trị khóa) tới bộ xử lý “partner” của nó ở trên nửa trên của siêu khối, đó là bộ xử lý Pi 2d-1 trong

đó là phép tính loại trừ OR (eXclusive OR). Mỗi bộ xử lý Pi trong nửa trên của siêu khối sẽ

gửi nửa dãy con dưới (nửa chứa các phần tử nhỏ hơn hoặc bằng giá trị khóa) tới bộ xử lý

“partner” của nó ở trên nửa dưới của siêu khối, đó là bộ xử lý Pi 2d-1 trong đó là phép tính

loại trừ OR.

Mỗi bộ xử lý sẽ trộn dãy phần tử mà nó nhận được từ “partner” với dãy các phần tử mà nó đang chứa để tạo thành một dãy mới đã được sắp xếp. Vì vậy, tất cả các phần tử nhỏ hơn hoặc bằng phần tử khóa sẽ được chứa trong các bộ xử lý của siêu khối d-1 chiều phía dưới và tất cả các phần tử lớn hơn phần tử khóa sẽ được chứa trong các bộ xử lý trên siêu khối d-1 chiều phía trên.Dưới đây là một minh họa:

Hình 2.27. Một minh họa về các bước thực hiện giải thuật Siêu Quicksort

Dưới đây là giả mã của giải thuật Siêu Quicksort

Giả sử tại thời điểm ban đầu mỗi bộ xử lý có n phần tử. Trong pha ban đầu, độ phức tạp về thời gian kỳ vọng là O (nlogn). Giả sử rằng mỗi bộ xử lý giữ lại n/2 phần tử và chuyển n/2 phần tử khác cho bộ xử lý partner sau mỗi bước chia và trộn, số phép so sánh kỳ vọng cần để trộn hai dãy con đã được sắp xếp thành một dãy đã được sắp xếp là O(n). Do thao tác chia và trộn được thực hiện trên các siêu khối d, d-1,…, 1 chiều, nên số phép so sánh kỳ vọng là O(nd). Nên số phép so sánh kỳ vọng của thuật toán Siêu Quicksort là O (n(logn+d)).

HYPERQUICKSORT()Biến toàn cục: n {số phần tử trên mỗi bộ xử lý}

d {chiều của siêu khối} i {số chiều của siêu khối hiên tại} Biến cục bộ: logicalNum {chỉ số của bộ xử lý}

partner {bộ xử lý partner để trao đổi} root {bộ xử lý gốc của siêu khôi hiện tại} splitter {giá trị khóa} Begin

For all Pi where 0 ≤ i < 2d do Sắp xếp các phần tử sử dụng Quicksort tuần tự If d>0 then For I = d downto 1 do root = gốc của khối i chiều chứa bộ xử lý logicalNum if logicalNum = root then splitter = giá trị trung bình của danh sách lưu bởi bộ xử lý logicalNum endif Bộ xử lý root phân phát splitter tới các bộ xử lý trong siêu khối i chiều Sử dụng splitter để phân hoạch các dãy phần tử trong các bộ xử lý

Partner = logicalNum 2d-1

if logicalNum <partner then Gửi danh sách chứa các giá trị bé hơn khóa tới bộ xử lý partner Nhận danh sách chứa các giá trị lớn hơn khóa từ partner Else Gửi danh sách chứa các giá trị lớn hơn khóa tới bộ xử lý partner Nhận danh sách chứa các giá trị bé hơn khóa từ partner

endif Trộn hai dãy con trên mỗi bộ xử lý thành một dãy đã được sắp xếp endfor endif endforEnd.

2.4 Thuật toán tìm kiếm song song trên danh bạTrong phần này, ta thảo luận về các thuật toán song song được sử dụng để giải quyết bài toán tìm kiếm một khóa nào đó trên tập dữ liệu đã được sắp xếp. Các thuật toán tuần tự đã được phát triển để tìm kiếm trên danh bạ với độ phức tạp là lô ga rít (log) đối với kích thước của tập dữ liệu.Tăng hiệu quả tìm kiếm bằng cách sử dụng nhiều tiến trình thực hiện tìm kiếm một cách đồng thời trên danh bạ trở nên ngày càng phổ biến. Đồng thời, việc tìm kiếm như vậy cũng đòi hỏi các chương trình dịch song song phải hỗ trợ khả năng có nhiều hơn một tiến trình truy cập đến một phần tử một cách đồng thời.Các thuật toán tìm kiếm thường thao tác trên một tập các phần tử gọi là khóa (keys), được lưu trữ trong một bảng có kích thước hữu hạn. Mục tiêu là tổ chức bảng và thực thi thuật toán sao cho các chức năng như chèn các khóa (cùng với các dữ liệu của nó) vào bảng. xóa khóa (cùng với các dữ liệu của nó) ra khỏi bảng, và tìm kiếm các khóa trong bảng được thực hiện càng nhanh càng tốt.

2.4.1 Độ phức tạp của tìm kiếm song song.

Một thao tác tìm kiếm một khóa được thực hiện trên một máy tính song song nhanh đến cỡ nào?. Ta sẽ đi tìm câu trả lời trong mục này.Định lý 2.4.1: Cho các số nguyên dương k, n và p, với n=(p+1)k-1, tìm kiếm một khóa trong một mảng n phần tử sử dụng mô hình CREW PRAM sử dụng không quá [log(n+1)/log(p+1)] phép so sánh.Chứng minh: Ta sẽ sử dụng phép qui nạp (induction) theo k để chỉ ra rằng [log(n+1)/log(p+1)] phép so sánh là đủ cho phép tìm kiếm một khóa trong một bảng kích thước n. Với k=1, thì n=(p+1)1-1 =p, hiển nhiên là chỉ cần một phép so sánh đối với p bộ xử lý trên một bảng p phần tử (mỗi bộ xử lý thực hiện so sánh khóa với một phần tử trong bảng) là đủ để tìm được khóa (số phép so sánh là [log(p+1)/log(p+1)]=1). Giả sử điều này đúng với tất cả các bảng có kích thước (p+1)j-1 với 1≤ j<k. Để tìm kiếm trên danh sách kích thước (p+1)k-1, trong lần so sánh đầu tiên của bộ xử lý thứ i với mọi 1 ≤ i≤ k, so sánh khóa có chỉ số i(p+1)k-1 . Sau bước này, một phần tử trong bảng có giá trị bằng khóa được tìm thấy, hoặc khóa không nằm trong phần này của bảng. Mỗi phần có kích thước (p+1)k-1-1. Theo giả thiết qui nạp k-1 phép so sánh là đủ để tìm kiếm khóa bất kỳ trong mỗi phần.Sử dụng định lý 2.4.1 ta có thể tính tốc độ của thuật toán tìm kiếm song song trên bảng đã được sắp xếp. Ta sử dụng số phép so sánh của thuật toán tìm kiếm nhị phân tuần tự trong trường hượp xấu nhất, chia cho số so sánh ít nhất thực hiện bởi thuật toán song song trong trường hợp xấu nhất, ta tìm được:

S = )1log(/)1log(

)1log(

pn

n = log (p+1)

Nói cách khác, tốc độ đạt được qua việc song song hóa là lô ga rít của số bộ xử lý được sử dụng.

2.4.2 Tìm kiếm song song trên máy tính đa bộ xử lý.

Một cách logic tiếp cận bài toán là lưu trữ cây tìm kiếm (search tree) trong bộ nhớ chia sẻ và gán các yêu cầu cho từng bộ vi xử lý. Mỗi bộ xử lý có thể chèn, xóa hoặc tìm kiếm. Đây là chiến lược cơ bản cho hai thuật toán sau:a. Thuật toán EllisEllis đề xuất một thuật toán song song cho phép tìm kiếm đồng thời trên cây nhị phân cân bằng (AVL tree). Dưới đây là những khái niệm liên quan:Chiều cao của một cây là độ dài đường đi lớn nhất từ nút gốc đến nút lá. Và một cây rỗng (cây không có gốc) là cây có độ cao bằng -1.Cậy nhị phân cân bằng là cây nhị phân có thuộc tính: đối với mọi nút v trên cây thì chiều cao củacây con bên trái và chiều cao của cây con bên phải của v khác nhau không quá 1. Xây dựng các cây tìm kiếm cân bằng là cách tiếp cận tối ưu để phép tìm kiếm nhị phân được cân bằng với thao tác tìm kiếm và chèn vào một khóa mới vào cây. Khi một khóa được chèn vào cây thì chỉ cần hai thao tác quay vòng là đủ để giữ cho cây cân bằng. Thuật toán chèn tuần tự: Mỗi nút v của một cây nhị phân cân bằng có 4 trường: key(v) là trường định danh duy nhất; left(v) là con trỏ trỏ đến cây con bên trái; right(v) là con trỏ trỏ đên cây con bên phải; và bal(v) là một số nguyên, bal(v) có giá trị là 0 nếu cây (gốc v) là cây cân bằng, là -1 nếu cây là cây lệch trái, là +1 nếu cây là cây lệch phải. Thuật toán chèn tuần tự có 3 pha. Trong pha đầu cây được tìm kiếm để tìm ra vị trí thích hợp để chèn nút lá mới. Trong khi tìm kiếm, một con trỏ sẽ được lưu lại vết tìm kiếm và trỏ đến nút cuối cùng trong quá trình tìm kiếm. Nút này được gọi là nút chốt (critical node). Mỗi nút cùng với đường dẫn tìm kiếm có các cây con cân bằng, thì nút gốc là các nut chốt. Pha thứ nhất kết thúc với một nút lá mới được bổ sung vào cây.Pha 2 bao gồm di chuyển tất cả các nút trên đường đi giữa nút mới được chèn vào v và các nút chốt c. Đối với mỗi nút w như vậy, nếu key(v) < key(w), thì bal(w)= -1; ngược lại bal(w)=+1.Pha 3 thay đổi giá trị bal(v) và quay cây nếu cần thiết. Nếu bal(c)=+1 và v được chèn cây con bên trái hoặc nếu bal(c) = -1 và v được chèn vào cây con bên phải, thì bal(c)=0 và không cần thiết phải quay cây. Nếu c là gốc vào bal(c)=0 thì bal(c) được đặt giá trị -1 hoặc +1 tùy thuộc vào v được chèn vào cây con trái hay cây con phải. Ngược lại, v được chèn vào cây con với độ cao lớn hơn và một thao tác quay cây sẽ được thực hiện.

Hình 2.28. Thao tác quay sẽ giữ cho cây AVL được cân bằng; a. quay 1 lần; b. quay 2 lần.

Thuật toán chèn song song: Mục tiêu của thuật toán chèn song song là giữ các tiến trình tìm kiếm và chèn ở trạng thái hoạt động (active) càng nhiều càng tốt. Chẳng hạn, xem xét cây nhị phân cân bằng ở hình 2.29 dưới đây. Giả sử rằng có hai tiến trình đang hoạt động: tiến trình thứ nhất chèn vào giá trị 37, và tiến trình thứ hai là tìm kiếm giá trị 13. Sau khi giá trị 37 được chèn vào cây, thì một thao tác quay cây được thực hiện để giưa cho cây cân bằng. Việc quay cây yêucầu giá trị của con trỏ trái và phải được thay đổi (hình 2.29.d đc vẽ lại từ hình 2.29.c). Giả sử rằng, tiến trình tìm kiếm giá trị 13 theo sau cây con trái của nút 6 và cây con trái của nút 25 khi cây được vẽ lại bằng hình 2.29.b. Giá trị 13 sẽ không được tìm thấy mặc dù giá trị này vẫn đang ở trên cây. Một vấn đề đụng độ nữa có thể xảy ra nếu hai tiến trình đang quay các cây con có một số nút chung nhau. Ellis giải quyết vấn đề này bằng cách thêm vào 3 trường khóa cho mỗi nút. Những trường khóa này cho phép các tiền trình tìm kiếm được khóa nếu tiến trình quay cây đang diễn ra. Đồng thời, nó cũng cho phép một tiến trình chèn khóa một tiến trình con chèn khác. Ba trường khóa được thêm vào mỗi nút của cây nhị phân cân bằng, đó là các khóa x, y và z. Một tiến trình thực hiện việc tìm kiếm sẽ kiểm tra khóa x trước khi truy cập đến trường dữ liệu của nút đó. Các khóa y được thiết lập bởi tiến trình chèn vào cây. Khóa z được dành cho thao tác quay cây. Có thể có nhiều tiến trình được phép chia sẻ khóa x, trong khi đó các khóa y và z không được chia sẻ. Nếu một tiến trình chèn giữ một nút với khóa z, thì không thể có các tiến trình khác có thể giữ các khóa x hoặc y hay cả hai.

Trong trường hợp có một thao tác quay cây đơn (single rotation), thì các khóa z trên các nút chốt và nút cha của nút chốt sẽ được thiết đặt (set). Một thao tác quay cây kép (double rotation) sẽ làm cho các khóa z trên các nút chốt, cha của nút chốt và các con của nút chốt trên đường đi của thao tác chèn (tìm kiếm trước khi chèn) sẽ được thiết đặt. Bảng dưới đây minh họa các trạng thái của các khóa tại các thời điểm khác nhau trong khi thực hiện bốn tiến trình của thao tác tìm kiếm và chèn.

Chèn 51 Tìm kiếm 46 Chèn 24 Tìm kiếm 17

Khóa x trên nút 26 Khóa y trên nút 26Xóa khóa y trên nút 26

Khóa x trên nút 34 Khóa y trên nút 26

Khóa x trên nút 49 Xóa khóa y trên nút 34Khóa y trên nút 49

Trạng thái hiện tại trên hình 2.30.a

Khóa x trên nút 66 Xóa khóa y trên nút 49

Chèn 51 Dừng

Khóa z trên nút 26

Khóa z trên nút 34 Chờ khóa x trên nút 26 được xóa.

Trạng thái hiện tại trên hình 2.30.b

Quay ở nút 34

Xóa tất cả các khóa

Khóa x trên nút 26

Dừng Khóa x trên nút 20

Khóa x trên nút 23

Chèn 25 Khóa y trên nút 26

Chờ z trên nút 26 được xóa

Trạng thái hiện tại trên hình 2.30.c

Khóa z trên nút 26

Xóa khóa y trên nút 26Khóa y trên nút 20

Trong suốt quá trình thực hiện thuật toán Ellis, một tiến trình thực hiện thao tác chèn sẽ thiết đặt khóa x khi duyệt cây. Khóa x từ nút cha của các nút chốt từ vị trí chèn vào sẽ được thiết lập trong suốt thời gian xảy ra thao tác chèn và quay cây. Việc làm này sẽ ngăn chặn xung đột có thể xảy

ra bởi các tiến trình thực hiện thao tác chèn trên các cây con có gốc là cha của các nút chốt. Chính vì lý do này mà số các thao tác chèn được thực hiện đồng thời rất hạn chế. Một vài năm sau, Ellis đã cải tiến thành công thuật toán này cho phép ít nút bị khóa hơn và nhiều tiến trình thực hiện thao tác chèn được xảy ra đồng thời hơn.

Hình 2.29. Biến đổi cây AVL khi giá trị 37 được chèn vào.

Tóm lại, thuật toán Ellis gán từng tiến trình cho các thao tác tìm kiếm hay chèn một khóa xác định. Số lượng các thao tác tìm kiếm và chèn có thể được thực hiện song song. Thuật toán có ba nhược điểm: một là không cho phép thực hiện thao tác xóa. Hai là, vẫn còn bị đụng độ (contention) đối với các tiến trình chia sẻ tài nguyên (các tiến trình chèn không cho các tiến trình chèn khác được thực hiện nếu cùng truy cập trên các cây con có nút chung). Thứ ba, thuật toán song song mất nhiều thời gian . Thậm chí một tiến trình tìm kiếm cũng phải kiểm tra các nút nó duyệt qua có khóa được thiết lập hay đã bị xóa.b. Thuật toán Manber và Ladner.

Manber và Ladner đã đề xuất một giải thuật tìm kiếm song song cho máy tính đa bộ xử lý truy cập bộ nhớ đồng bộ (UMA multiprocessors) cho phép thực hiện thao tác xóa bỏ một nút trên cây nhị phân cân bằng nhưng làm mất thuộc tính cân bằng của cây. Thuật toán này không duy trì được thuộc tính cân bằng của cây mà các tác giả hy vọng rằng nhờ việc xóa và chèn một cách ngẫu nhiên sẽ duy trì được một cây cân bằng hợp lý. Điều hy vọng này chỉ đúng trong một số điều kiện cụ thể. Một sự nhượng bộ cho hai tác giả là thuật toán của họ đơn giản hơn các thuật

toán khác nhiều. Bởi vì các tiến trình chèn và xóa không có trách nhiệm quay cây. Một đặc điểm thú vị của thuật toán này là sử dụng các tiến trình duy trì để xóa các nút.Mỗi nút v trên cây tìm kiếm có 10 trường gắn với nó:Key(v): trường khóa của nútData(v): mục dữ liệu của nútLeft(v): con trỏ trỏ đến cây con tráiRight(v): con trỏ trỏ đến cây con bên phải.Parent(v): con trỏ cha của vGarbage(v): có giá trị là đúng (true) nếu v đã bị loại khỏi cây.Redundant(v): có giá trị là đúng (true) nếu có một bản sao (copy) khác của v trên cây.Copy(v): có giá trị là đúng (true) nếu v là một bản sao của nút khác trên cây. Userlock(v): khóa có thể được thiết đặt bởi bất kỳ tiến trình nào.Mlock(v): khóa có thể được thiết đặt bởi bất kỳ một tiến trình bảo trì.Gốc của cây là một nút đặc biệt với khóa ∞. Nó không chứa dữ liệu và không bị xóa. Nó sẽ được sử dụng để đơn giản cho giải thuật song song.Có hai lý do tại sao các nút cần được xóa. Trước hết, một nút cần được khóa để bảo đảm rằng tại một thời điểm chỉ duy nhất một tiến trình được cập nhật dữ liệu. Thứ hai, các nút cần được khóa để bảo đảm rằng hai hay nhiều tiến trình không thể thay đổi hình dạng của cây tại cùng một thời điểm tại cùng một vị trí. Hai mục tiêu này không độc lập với nhau. Chẳng hạn, một tiến trình không thể cho phép xóa một nút trong khi đó thì có một tiến trình khác đang cập nhật nó. Vì vậy, chỉ cần một khóa userlock, được sử dụng cho cả hai mục đích trên.Mọi khóa gắn với một nút duy nhất. Nếu khóa đã xuất hiện trong cây, sẽ có một nút gắn với nó. Nếu một khóa (key) không xuất hiện trong cây, có thể có một nút sắp được chèn vào cây gắn với nó. Vì vậy, các nút trong được gắn với các khóa xác định, trong khi các nút lá có thể được gắn với một số giá trị khóa tương ứng với một khoảng các giá trị khóa. Các thao tác cơ bản như: cập nhật, chèn, và xóa một nút. Những thao tác này bắt đầu bởi thực hiện một thao tác tìm kiếm mạnh (strong search), nó sẽ tìm các nút gắn với một khóa và khóa trường userlock của nút. Nếu trường userlock đã được khóa trước đó, tiến trình thực hiện thao tác sẽ bị khóa cho đến khi nút được mở khóa. Chỉ duy nhất một thao tác cơ bàn có thể được thực hiện trên một nút tại một thời điểm. Ngược lại với thuật toán Ellis, tất cả các thao tác có thể được thực hiện bằng việc khóa một nút duy nhất. Điều này đem đến một phạm vị rộng hơn cả xử lý đồng thời. Chú ý rằng, ngoại trừ trường dữ liệu, tất cả các trường của một nút có thể được duyệt trong khi nút đó đang bị khóa. Điều này cũng cho phép việc tìm kiếm vẫn được tiếp tục mặc dù có một nút trong trên đường đi của nó bị khóa.Các thao tác người dùng cơ bản: bao gồm các thao tác: tìm kiếm mạnh (strong search), tìm kiếm yếu (weak search), cập nhật, chèn, và xóa. Dưới đây ta sẽ trình bày về các thao tác này.Vì việc tìm kiếm không thay đổi cây, khi ta tiến hành thực hiện tìm kiếm song song cũng tương tự như tìm kiếm tuần tự. Tuy nhiên, có một yếu tố quan trọng cần phải xem xét đó là: điều gì sẽ xảy ra nếu việc tìm kiếm được thực hiện và kết quả tìm kiếm được báo cáo, nhưng một tiến trình khác thay đổi cây trong khoảng thời gian tìm kiếm đã kết thúc và kết quả đã được báo cáo? Yếu tố này đôi khi là không hợp lệ đối với việc tinh toán: vào thời điểm khác thì yếu tố này lại trở nên quan trọng. Do đó, ta sẽ định nghĩa hai loại thuật toán tìm kiếm dưới đây.

Tìm kiếm yếu (weak search): sẽ trả lại kết quả không bảo đảm được kết quả này là mới nhất (up-to-date). Tìm kiếm yếu nên được dùng bất cứ khi nào có thể, bởi vì nó không yêu cầu khóa bất kỳ nút nào. Vì vậy, thuật toán song song không mất thời gian và một tiến trình thực hiện tìm kiếm yếu không bị cản trở bởi các tiến trình khác.

Tìm kiếm mạnh (strong search): sẽ tìm kiếm một khóa cho trước và trả lại nút v gắn với khóa đó. Để chắc chắn rằng v vẫn là nút chứa khóa mà nó cần, tiến trình sẽ thực hiện thao tác tìm kiếm yếu, sau đó khóa v. Sau khi nút v bị khóa thì tiến trình sẽ kiểm tra xem v vẫn chứa khóa. Giữa khoảng thời gian v được tìm thấy và v bị khóa, có thể có ba sự kiện làm mất hiệu lực giữa nút v và khóa của nó. Một là, v có thể bị xóa khỏi cây (garbage(v) được đặt giá trị true). Hai là, nếukey(v) không phải là khóa đang được tìm kiếm, một nút khác có thể được chèn vào và đang được gán giá trị khóa. Ba là, v có thể trở thành một nút thừa (redundant(v) được đặt là true). Các nút thừa được tạo ra như là một hiệu ứng phụ (side-effect) của thao tác xóa nút. Vì vậy, khi tìm kiếm mạnh trả về một nút, nút đó sẽ được gán khóa và bị khóa. Nút được mở khóa chỉ khi một trong các thao tác cập nhật, chèn, hoặc xóa đã hoàn thành.Trong thao tác xóa, thuật toán Manber và Ladner khá đơn giản, bởi vì tiến trình xóa chỉ thực hiện thao tác xóa nút logic. Các tiến trình bảo trì sẽ có nhiệm vụ xóa nút một cách vật lý. Tiến trình xóa sử dụng tìm kiếm mạnh để tìm ra nút theo khóa tìm kiếm và khóa nút đó. Giả sử nút đó được tìm thấy thì data(v) được đặt bằng rỗng (nil). Tiến trình xóa sẽ đặt v vào danh sách chứa các nut xóa (delete list) để rồi sau đó tiến trình xóa có thể xóa vật lý nút này.Thao tác chèn đồng thời bắt đầu bằng thực hiện tìm kiếm mạnh đối với nút v. Nếu một nút được tìm thấy theo khóa, nó có thể được xóa logic, thì tiến trình sẽ thêm một trường mới rồi mở khóa nút v và dừng. Nếu v chưa được xóa một cách lô gic, tiến trình sẽ thông báo v đang tồn tại, mở khóa và dừng. Giả sử khóa đó không có ở trên cây, thì v là nút lá sẽ trở thành nút cha của nút được chèn vào, và thao tác chèn được thực hiện tương tự như thuật toán tuần tự. Sau khi con trỏ con của v trỏ vào nút đã chèn vào thì tiến trình sẽ mở khóa cho nút v và dừng.

Hình 2.30. Tìm kiếm và chèn song song trên cây AVL

Các tiến trình bảo trì (maintainance processes) các tiến trình bảo trì sẽ xóa vật lý các nút từ cây tìm kiếm. Nhắc lại rằng khi một nút được xóa, con trỏ của nó được được đặt vào danh sách xóa. Các tiến trình bảo trì chờ để truy cập danh sách để lấy con trỏ của các nút cần xóa.Nếu nút v cần được xóa và v chỉ có một nút con thì thao tác xóa khá đơn giản: con trỏ cha của v sẽ trỏ đến con trỏ con của v, và v sẽ được “tách” ra khỏi cây (hình 2.31). Nếu v là nút lá thì contrỏ của nút cha sẽ được đặt bằng con trỏ rỗng (nil).Nút v có thể được dùng lại trong bao lâu ? Mặc dù nút v không còn là một phần của cây, một tiến trình có thể truy cập v trong khi nó đang được loại khỏi cây. Mục đích của hàm garbage(v) là để thông báo tới tiến trình đó là v không còn trên cây. Vì parent(v) vẫn còn trỏ đến nút cha của nó, nếu không thì một tiến trình tìm kiếm sẽ được thực hiện trên cây và tiếp tục.Như ta đã biết, v không thể được sử dụng ngay lập tức. Manber và Ladner đề xuất nên sử dụng thuật toán Kung và Kehman (1980) để loại bỏ nút vào thùng rác (garbage collection). Thuật toán này sử dụng ba danh sách: danh sách rác bị động (passive garbage list), danh sách rác chủ động (passive garbage list) và danh sách có sẵn (available list). Khi một tiến trình bảo trì loại bỏ một nút từ cây, nút đó sẽ được đặt vào danh sách rác bị động. Danh sách này sẽ phát triển cho đến khi tiến trình bảo trì sẵn sang thực hiện “thu gom” rác. Việc “thu gom” rác bắt đầu bằng việc sao

chép một nhóm nút từ danh sách rác bị động vào danh sách rác chủ động, và chú ý rằng tiến trình nào đang hoạt động tại thời điểm sao chép. Khi tất cả các tiến trình này dừng, danh sách rác chủ động được bổ sung vào danh sách có sẵn. Do chỉ có một tiến trình có thể truy cập đến các nút trong danh sách rác bị động được hoạt động khi tạo danh sách rác chủ động, các nút thực chất không được kích hoạt để sử dụng lại khi các tiến trình này dừng.Thuật toán xóa vật lý phức tạp hơn nếu nút v có hai nút con. Quá trình xóa nút được thực hiện qua hai bước (hình hình 2.32); Bước 1: nút w có khóa nhỏ hơn khóa v (key(v)) được tìm thấy(hình hình 2.32.a). Nút w có nhiều nhất một nút con (vì nó không thể có nút con bên phải). Vì vậy, dễ dàng xóa nút w bằng thuật toán đã được trình bày ở trên (hình hình 2.32.b).Bước thứ 2 là thay thế v bởi w (hình hình 2.32.c). Vì w là nút con kế tiếp của v, cây vẫn duy trì được tính nhất quán (consistent). Tuy nhiên, ta phải thực hiện việc xóa theo một cách khác để bảo đảm rằng một tiến trình tìm kiếm v luôn có thể truy cập đến bản sao của v.

Hình 2.32: xóa một nút có 2 con ở mức khái niệm.

Thuật toán sử dụng bởi Manber và Ladner được minh họa trong hình 11-7. Đầu tiên, tạo ra một bản sao của w là w’. Chú ý rằng data(w’)=data(w) và copy(w’)=true. Bước 2 là, đặt left(w’) trỏ tới left(v) và right(w’) trỏ tới right(v). Bước 3 là, đặt right(w) trỏ tới w’, và đặt redundant(w)=true. Điều gì sẽ xảy ra nếu một tiến trình tìm kiếm nút w đang trên đường từ nút v đến nút w. Tiến trình này có thể muốn chèn vào nút con bên phải của w. Khi tiến trình tìm thấy nút w, nó sẽ phát hiện thấy redundant(w)=true và sẽ theo sau right(w) đến w’, mà nó sẽ tiếp tục tới nút t. Bước 4 là. Loại bỏ nút v bằng việc đặt con trỏ con của parent(v) trỏ vào w’ và đặt garbage(v)=true.

Hình 2.33. Xóa một nút có 2 con

Nút w không bị xóa ngay, bởi vì có thể có tiến trình đang tìm kiếm w trên đường từ v đến w. Một phương pháp tương tự như thuật toán gom rác (garbage collection) để giải bài toán. Ta đặt nút w vào một danh sách rác bị động. Các nút trong danh sách rác bị động sẵn sàng cho việc xóa vật lý sau khi tất cả các tiến trình đang thực hiện trong thời gian thay thế đã dừng. Khi w sẵn sàng cho xóa vật lý thì tiến trình đó sẽ thực hiện khá đơn giản vì w chỉ có một nút con.

2.5 Thuật toán song song trên đồ thịPhần này trình bày hai thuật toán tìm kiếm song song trên đồ thị để giải hai bài toán cơ bản trên đồ thị: bài toán tìm đường đi ngắn nhất và tìm cây khung nhỏ nhất.

2.5.1 Thuật toán song song tìm đường đi ngắn nhất

Bài toán tìm đường đi ngắn nhất được phát biểu như sau: ta cần tìm đường đi ngắn nhất từ một đỉnh nguồn (source) tới tất cả các đỉnh trong một đồ thị có trọng số và có hướng.Giả sử weight(u,v) biểu diễn độ dài của cạnh nối hai đỉnh u và v, nếu không tồn tại cạnh này trên đồ thị thì weight(u,v) = ∞.Từ năm 1959, Moore đã đề xuất một thuật toán tuần tự để giải bài toán trên. Trong thuật toán này, hàm distance(v) được gán giá trị khởi tạo là ∞ đối với mọi đỉnh v V – {s}. Khoảng cách từ s tới s bằng 0. Một hàng đợi chứa các đỉnh đã được duyệt, ban đầu hàng đợi chỉ chứa một đỉnh nguồn s. Trong khi hàng đợi chưa bị rỗng, đỉnh u từ đầu hàng đợi bị loại bỏ, và tất cả các cạnh (u,v) E sẽ được thử. Nếu distance(u) + weight(u,v) < distance(v) thì một đường đi mới tới v (qua u) được tìm thấy. Trong trường hợp này, distance(v) được đặt lại bằng distance(u) + weight(u,v) và v được đặt vào cuối hàng đợi. Thuật toán tiếp tục tiến trình này cho đến khi hàng đợi rỗng.

Hình 2.34. Minh họa thuật toán Moore.

Thủ tục INITIALIZE, được gọi ở dòng thứ 3 khởi tạo khoảng cách tới tất cả các đỉnh (không kể đỉnh nguồn s) là ∞, và khoảng cách từ s đến s bằng 0. Vòng lặp for từ dòng 12 đến 20 tìm kiếm đường đi ngắn nhất đến các đỉnh khác có thể đến được từ u.

SHORTEST PATH Parameter n {số đỉnh của đồ thị} Global distance {phần tử i chứa khoảng cách từ s đến i}

s {đỉnh nguồn} weight {chứa trọng số của mỗi cạnh}

1 Begin

2 For i=1 to n do

3 INITIALIZE(i)

4 Endfor

5 Chèn s vào cuối hàng đợi

6 While hàng đợi không rỗng do

7 SEARCH()

8 Endwhile

9 End

SEARCH() Local newdistance {khoảng cách tới v nếu đường đi từ u đến v ngắn nhất}

u {đỉnh u} v {đỉnh v}

10 Begin

11 Loại đỉnh u từ đầu hàng đợi

12 For mỗi cạnh (u,v) trong đồ thị do

13 newdistance = distance(u) + weight(u,v)

14 If newdistance<distance(v) then

15 distance(v) = newdistance

16 If v không có trong hàng đợi then

17 đặt v vào cuối hàng đợi

18 Endif

19 Endif

20 Endfor

21 End

Phiên bản tuần tự của thuật toán Moore tìm đường đi ngắn nhất trên đồ thị

Làm thế nào để song song hóa giải thuật trên. Có hai cách thức cần xem xét. Cách thứ nhất là song song hóa vòng lặp từ dòng 12 đến dòng 20. Mỗi đỉnh u có một số cạnh đi ra từ đỉnh đó (đồ thị đang xét là có hướng) ta có thể xử lý song song để tìm đường đi ngắn nhất qua u. Cách thứ hai là song song hóa vòng lặp while từ dòng 6 đến dòng 8. Tại bất kỳ thời điểm nào khi thuật toán thực hiện , có thể có nhiều đỉnh trong hàng đợi. Có thể có nhiều cạnh được duyệt đồng thời. Vậy cách song song hóa nào tốt hơn. Có hai lý do ta có thể nghiên về cách thứ 2. Đó là, cách thứ 2 có thể đạt được hiệu suất và tốc độ song song tốt hơn và cách thứ nhất bị giới hạn bởi số cạnh của mỗi đỉnh. Nếu đồ thị quá thưa (ít cạnh trên mỗi đỉnh) số tiến trình được thực hiện song song sẽ ít.Thuật toán song song sau đây dưa trên cách thức thứ 2. Hàng đợi được khởi tạo với một đỉnh nguồn, thì một số tiến trình không đồng bộ sẽ được tạo ra. Mỗi tiến trình này hoàn thành một số bước loại bỏ một đỉnh trong hàng đợi, thử các cạnh ra từ đỉnh và chèn các đỉnh với đường đi ngắn hơn vào hàng đợi.Vòng lặp for từ dòng 2 đến dòng 4 của thuật toán tuần tự dễ dàng biến đổi để xử lý song song sử dụng cách thức tiền lập lịch (pre-scheduling). Xử lý song song vòng lặp for từ dòng 2 đến dòng 6 được trình bày ở hình 12-8. Vòng lặp while từ dòng 6 đến dòng 8 của thuật toán tuần tự phải được thay đổi để thể hiện sự tồn tại của các tiến trình không đồng bộ thực hiện thủ tục SEARCH một cách song song. Rõ ràng là nó không phù hợp cho một tiến trình để dừng khi nó phát hiện ra rằng hàng đợi đã rỗng (tại sao lại như vậy: vì các tiến trình được thực hiện một cách độc lập và đồng thời). Do vậy, một phương pháp phức tạp hơn phải được sử dụng. Trong thuật toán song song sẽ có hai biến được sử dụng cùng nhau để xác định có hay không có việc phải làm. Biến thứ nhất là waiting, là một mảng để theo dõi các tiến trình đang đợi. Biến thứ hai kiểu Boolean halt, halt = true khi tất cả các tiến trình đang chờ.Không có tranh chấp giữa các tiến trình nếu mỗi tiến trình được bảo trì một danh sách riêng các đỉnh sắp được tìm kiếm, hoặc chèn hay xóa. Nếu kích thước của các danh sách này lớn thì để

mỗi tiến trình tự quản lý danh sách riêng của nó có thể gây ra mất cân bằng tải đối với khối lượng công việc.

SHORTEST PATH (MULTIPROCESSOR) Parameter n {số đỉnh trên đồ thị}

p {số tiến trình} Global distance {distance (i) chứa khoảng cách từ s đến i}

halt {= true, nếu các tiến trình dừng} s {đỉnh nguồn} weight {trọng số của mỗi cạnh}

1 Begin

2 For all Pi where 1 ≤ i ≤ p do

3 For j=i to n step p do

4 INITIALIZE(j)

5 Endfor

6 Endfor

7 Đặt s vào hàng đợi

8 halt = false

9 For all Pi where 1 ≤ i ≤ p do

10 Repeat SEARCH(i) until halt

11 Endfor

12 End

SEARCH(i); value i {số tiến trình} local newdistance {khoảng cách tới v}

u {đỉnh u} v {đỉnh v}

1 Begin

2 Khóa hàng đợi

3 If hàng đợi rỗng then

4 waiting(i) = true

5 If i=1 then

6 halt =waiting(2) AND waiting(2) AND…. waiting(p)

7 Endif

8 Mở khóa hàng đợi

9 Else

10 lấy u ra khỏi hàng đợi

11 waiting(i) = false


13 For mỗi cạnh (u,v) trong đồ thị do

14 newdistance=distance(u)+weight(u,v)

15 Lock(distance(v))

16 If newdistance < distance (v) then

17 Distance(v) = newdistance

18 Unlock(distance(v))


20 Khóa hàng đợi


22 Lấy v ra khỏi hàng đợi

23 Endif


25 Endif

26 Else Unlock(distance(v))

27 Endif

28 Endfor

29 Endif

30 End.

Thuật toán song song tìm đường đi ngắn nhất trên máy tính UMA đa bộ xử

lý

Mảng liên kết là cấu trúc dữ liệu cho phép liên kết các danh sách có kích thước khác nhau sao cho việc chèn và tìm kiếm các phần tử trong danh sách có thể được thực hiện song song mà không có xung đột. Giả sử rằng trong một vòng lặp đơn không có bộ vi xử lý thực hiện thao tác chèn nhiều hơn w phần tử. Trong mảng liên kết, trong trường hợp đó chứa p(w+p) phần tử, w+p phần tử trên một tiến trình. Trong một nhóm liên tiếp nhau w+p vị trí, một tiến trình có thể chứa tên các phần tử được tìm kiếm trong vòng lặp tiếp theo. Nếu bộ vi xử lý i, 1 ≤ i ≤ p, sinh ra tên của ei phần tử được xem xét trong vòng lặp tiếp theo, thì các vị trí (i-1)(w+p) +1 đến (i-1)(w+p) + ei +p chứa các giá trị -i (w + p +1) lần lượt giảm tới – ( i(w+p) + p)). Trong vòng lặp kế tiếp, khi các phần tử với các tên trong mảng liên kết được thử, bộ xử lý i (1 ≤ i ≤ p) sẽ thử mỗi vị trí thứ p, bắt đầu với vị trí thứ i. Nếu giá trị gặp phải lớn hơn zero, đó là đỉnh cần tìm kiếm. Nếu giá trị nhỏ hơn zero, đó là một con trỏ, và bộ xử lý sẽ nhảy đến chỉ số đã được chỉ ra. Khi con trỏ có giá trị ít hơn –p(w+p), việc tìm kiếm sẽ dừng,Thủ tục EXAMINE sau đây minh họa một tiến trình loại bỏ các phần tử chia sẻ từ một mảng chứa các chỉ số đỉnh và các con trỏ.

EXAMINE (a,i,p,w) Value a[1..p(w+p)], {mảng chứa số hiệu đỉnh và con trỏ}

i, {số hiệu tiến trình} p, {số các tiến trình} w, {kích thước mảng con gắn với mỗi tiến trình} Local j {chỉ số của mảng a}

1 Begin

2 j=i

3 While j ≤ p * (w+p) do

4 If a[j] < 0 then

5 j = -a[j] {con trỏ kế tiếp}

6 Else

7 Thao tác với đỉnh có giá trị a[j]

8 j = j+p

9 Endif

10 Endwhile

11 End

Không gian lưu trữ mảng liên kết có thể rất lớn. Trừ khi nó có thể được bảo đảm không phải tất cả các thao tác chèn có thể được thực hiện bằng một bộ xử lý đơn, thì không gian dành cho mảng liên kết phải xấp xỉ p lần không gian lưu trữ một mảng thông thường. Phiên bản dữ liệu song song của thuật toán Moore có thể được sửa đổi để sử dụng mảng liên kết. Trong một vòng lặp đơn, mỗi tiến trình có một số đỉnh để thử. Mỗi tiến trình xử lý danh sách các đỉnh riêng của nó để tìm đường đi ngắn hơn và xây dựng các liên kết tới danh sách của tiến trình kế tiếp. Trong vòng lặp kế tiếp thì những danh sách này được xử lý song song. Có hai mảng được sử dụng. Trong bất kỳ lần lặp nào luôn có một mảng được đọc trong khi mảng kia được ghi. Lần lặp kế tiếp thì vai trò của hai mảng được hoán đổi.

Hình 2.35. Nếu không sử dụng khóa hàng đợi thì hai tiến trình cùng cập nhật giá trị distance(v) sẽ

gây ra lỗi.

2.5.2 Thuật toán song song tìm cây khung bé nhất

Bài toán tìm cây khung bé nhất được phát biểu như sau: cho một đồ thị liên thông, vô hướng, có trọng số; hãy tìm cây khung nhỏ nhất (một cây chứa tất cả các đỉnh với trọng số bé nhất). Phần

dưới đây ta sẽ thảo luận về hai thuật toán song song dựa trên giải thuật tuần tự của Sollin (1977) và của Kruskal (1956) để giải bài toán này.

a.Thuật toán SollinTrước hết, ta hãy khảo sát phiên bản giải thuật Sollin tuần tự. Trong giải thuật này, ta bắt đầu với một rừng gồm n đỉnh tách biệt nhau. Mỗi đỉnh được xem như một cây. Trong mỗi vòng lặp, thuật toán tìm ra một cạnh để nối hai cây với nhau, không thể có hai cây nào được nối bằng nhiều hơn một cạnh. Đồng thời, cũng phải bảo đảm chúng không thể tạo thành các chu trình. Tiến trình này tiếp tục cho đến khi chỉ còn một cây (tất cả các đỉnh đã được kết nối). Vì số lượng cây sẽ được giảm đi ít nhất 2 lần trong mỗi lần lặp, nên thuật toán Sollin yêu cầu nhiều nhất [logn] lần lặp để tìm ra được cây khung nhỏ nhất. Mỗi lần lặp yêu cầu nhiều nhất O(n2) phép so sánh để tìm ra được cạnh bé nhất qua mỗi đỉnh. Vì vậy, thuật toán tuần tự có độ phức tạp O(n2logn).Dưới đây là giả mã của phiên bản tuần tự của thuật toán:

MINIMUM-COST SPANNING TREE() Parameter n {số đỉnh} Global closest[], {khoảng cách của cây gần nhất}

edge[], {cạnh nối cây với cây gần nhất} i, T, {cây khung nhỏ nhất} u,w {điểm cuối của cạnh đang xem xét} weigh[] {chứa trọng số của cạnh}

1 Begin

2 For i=1 to n do

3 Đỉnh i được khởi tạo trong tập i

4 Endfor

5 T = ø

6 While |T| < n-1 do

7 For mỗi cây i do

8 closest[i] = ∞

9 Endfor

10 For mỗi cạnh (v,w) do

11 If FIND(v) ≠ FIND(w) then

12 If weight(v,w) < closest(FIND(v)) then

13 closest(FIND(v)) = weight(v,w)

14 edge(FIND(v)) = (v,w)

15 Endif

16 Endif

17 Endfor

18 For mỗi cây i do

19 (v,w) = edge(i)

20 If FIND(v) ≠ FIND(w) then

21 T = T {(v,w)}

22 UNION(v,w)

23 Endif

24 Endfor

25 Endwhile

26 End

Phiên bản tuần tự của thuật toán tìm cây khung nhỏ nhất của Sollin

Một minh họa của thuật toán được thể hiện ở hình dưới đây:

Hình 2.36. Một ví dụ minh họa thuật toán Sollin.

Chú ý rằng thuật toán này sử dụng các tập hợp (set) để lưu các đỉnh trong cây. Hàm FIND(v) nhận đầu vào là một đỉnh v, trả lại tên của tập chứa v. Thủ tục UNION nhận vào hai tham số là hai đỉnh, thực hiện phép hợp gai tập hợp chứa v và w; nói cách khác, UNION thực hiện phép kết nối hai cây chứa đỉnh v và w.Làm thế nào để song song hóa giải thuật tuần tự trên?. Thông thường, ta có thể song song hóa vòng lặp ngoài cùng. Tuy nhiên, trong trường hợp này thì vòng lặp ngoài cùng while bị phụ thuộc ràng buộc dữ liệu giữa các lần lặp. Mỗi cây đang tồn tại tại vòng lặp thứ i phải được kết hợp với cây lân cận trước khi lần lặp thứ i+1 được bắt đầu. Vì vậy, xử lý song song phải được thực hiện bên trong vòng lặp while. Các dòng lệnh từ 7 đến 9 có thể được song song hóa bằng cách tiền lập lịch (prescheduling). Mỗi bộ xử lý chịu trách nhiệm tạo ra 1/p cây. Vòng lặp for từ dòng 10 đến 17 cũng có thể được song song theo cách trên. Đây là cách hiệu quả nhất bởi có thể gán mỗi bộ xử lý với các đỉnh đang được chia sẻ, sau đó cho phép chúng thử tất cả các cạnh từ tập này.

Việc song song hóa từ dòng 18 đến 24 phức tạp hơn. Giả sử rằng một bộ vi xử đang kết nối cây A với cây B, trong khi bộ vi xử lý khác kết nối cây B với cây A. Biến edge(A) chứa cạnh (vA, wA) với độ dài k. Biến edge(B) cũng chưa cạnh (vB, wB) với độ dài k. Nếu cả hai bộ xử lý thực hiện dòng 20 trước khi thực hiện phép toán UNION ở dòng 22 thì cả hai cạnh sẽ được thêm vào cây T và kết quả là sẽ sinh ra lỗi. Do vậy, nếu các dòng 18 đến 24 được song song hóa thì các cây FIND(v) và FIND(w) phải được khóa trước dòng 20 và phải được mở khóa (unlocked) trước sau dòng 23 vì ta chỉ có phép một bộ xử lý được thực hiện tại một thời điểm trong trường hợp mở rộng cây khung.

Định lý: phiên bản song song hóa giải thuaatk Sollin miêu tả ở trên có độ phức tạp O(log(n(n2/p+n/p+n+p)). Chứng minh:Một chuỗi n thao tác UNION và FIND sẽ có độ phức tạp là O(nlog*n) và thời gian dành cho một thao tác như vậy là O(log*n); vì vậy, độ phức tạp này được xem như hằng số.Thực hiện song song vòng lặp for từ dòng 7 đến 9 có độ phức tạp O(n/p + p), vòng lặp 10 đến 17 có độ phwvs tạp O(n2/p + p), và vòng lặp từ dòng 18 đến 24 có độ phức tạp O((n/p)p + p). Thừa số p trong lần lặp cuối cùng vì trong trường hợp xấu nhất, một bộ xử lý chờ để khóa một cây A có thể phải đợi bộ xử lý khác khóa và mở khóa cây A. Vì vòng lặp while ngoài cùng cần O(logn) thời gian nên phiên bản song song của thuật toán Sollin là O((n2/p+n/p+n+p)logn).

Độ phức tạp này đạt giá trị nhỏ nhất khi p=O( n ).

b. Thuật toán KruskalThuật toán Kruskal bắt đầu với một đồ thị gồm một rừng các đỉnh riêng biệt. Các cạnh sẽ được duyệt theo thứ tự tăng dần của trọng số, và mỗi cạnh kết nối với hai cây không giao nhau sẽ được bổ sung vào cây khung nhỏ nhất (nói cách khác, tất cả các cạnh mà không tạo ra chu trình trong đồ thị sẽ được thử để chọn). Thuật toán dừng khi chỉ gồm một cây là một cây khung nhỏ nhất.Hình dưới đây là một ví dụ minh họa cho thuật toán Kruskal:

Hình 2.37. Một ví dụ minh họa cho thuật toán Kruskal.

Yoo (1983) đã phát biểu rằng: một máy tính đa xử lý UMA với [logm] bộ xử lý có thể loại bỏ một phần tử từ một heap m phần tử với thời gian là hằng số.

Mô tả thuật toán: Xét hình dưới đây:

Hình 2.38. Thuật toán xử lý xen kẽ của Yoo

Thuật toán xử lý xen kẽ (pipelined algorithm) của Yoo được minh họa ở hình trên. Một mảng được dùng để triển khai heap với gốc của heap được lưu lại trong phần tử đầu tiên và con trái và phải của nút i được lưu trong phần tử thứ 2i và 2i+1. Heap là một cây nhị phân hoàn chỉnh với p mức, p là số bộ vi xử lý. Các nút là được gán giá trị ∞ nếu cần. Trong khi thực hiện, một nút được gọi là đầy đủ (full) nếu no chứa một giá trị nào đó (kể cả ∞). Một nút là rỗng nếu giá trị của nó đã được chuyển đến cha của nó và nó chưa nhận được giá trị thay thế từ con của nó. Mảng flag chỉ ra mức nào có nút rỗng; flag(i)=empty nếu ở mức i có nút rỗng; ngược lại flag(i)=full.Nếu flag(i)=empty thì empty_node(i) sẽ chỉ ra nút nào rỗng. Với mỗi 2 ≤ i ≤ p, bộ xử lý i được gán công việc là làm cho tất cả các nút thứ i-1 trở thành full. Nếu flag(i-1) = empty và flag(i) =full, thì bộ xử lý thứ i sẽ gán các giá trị thích hợp (lấy từ mức i) cho các nút ở mức i-1. Khi đó flag(i-1)= full, và flag(i) =empty. Khi một nút là trở thành empty, thì nó sẽ được gán giá trị ∞. Cuối cùng, các giá trị ∞ được gán vào cây. Bộ xử lý 1 sẽ làm rỗng nút 1 bất kỳ khi nào nó trở thành full và dừng thủ tục khi nút 1 có giá trị ∞.Giả mã của thuật toán được mô tả dưới đây:

HEAP CONSTRUCTION (SISD) Parameter d {độ sâu của heap} Global k,v,w {các phần tử của heap}

Key[1..(2d+1-1)] {heap} l {số mức}

1 Begin

2 For l=d downto 1 do

3 For nút không phải là nút lá ở mức l do

4 K=key(v)

5 Repeat

6 w = con của v với khóa nhỏ hơn

7 If k>key[w] then

8 Key[v]=key[w]

9 v=w

10 Else

11 Exit loop

12 Endif

13 Until v là nút lá

14 Key[v]=k

15 Endfor

16 Endfor

17 End

Vòng lặp trong các dòng 3 đến 15 có thể được song song hóa bởi cách thức tiền lập lịch; mỗi bộ vi xử lý tạo ra các nút không phải là nút lá chia sẻ trong heap ở mức l. Một cách tốt hơn là cho phép xây dựng heap với hai con được tạo 1 lần để giải quyết đồng thời tính đồng bộ khi các mức được xử lý đồng thời.

2.7 Kết chươngPRAM là một mô hình được mở rộng từ mô hình xử lý tuần tự RAM. Một thuật toán PRAM cho phép thực hiện đồng thời nhiều bước trên tập dữ liệu lớn với số lượng bộ vi xử lý tham gia thực hiện chương trình không bị hạn chế. Các mô hình của PRAM có thể có các cơ chế cho phép nhiều bộ xử lý đọc hoặc ghi đồng thời một ô nhớ trong bộ nhớ toàn cục.Các thuật toán song song nhân hai ma trận được thiết kế cho các kiến trúc song song khác nhau. Gentleman đã chỉ ra rằng nhân hai ma trận kích thước n x n trên máy tính SIMD với các bộ xử lý được tổ chức theo mạng hình lưới hai chiều có độ phức tạp O(n), và đó là tối ưu. Dekel cũng đề xuất một giải thuật rất hiệu quả cho phép n3=23q bộ xử lý trên một máy SIMD với các bộ xử lý được tổ chức theo hình siêu khối để nhân hai ma trận với độ phức tạp O(logn).Ba giải thuật sắp xếp song song mà ta đã tìm hiểu đều rất hiệu quả. Trong đó, giải thuật sắp xếp hoán chuyển chẵn lẻ trên máy tính mà các bộ vi xử lý được tổ chức theo mạng hình lưới một chiều rất đơn giản nhưng tối ưu với độ phức tạp O(n). Thuật toán sắp xếp trộn Bitonic được thực hiện một cách đệ quy rất hiệu quả trên máy tính mà các bộ xử lý được tổ chức theo mạng hoán vị-di chuyển hoặc siêu khối với độ phức tạp O(log2n). Giải thuật quicksort song song và siêu quicksort được thiết kế cho máy tính MIMD theo chiến lược chia để trị tuy không đạt được giảm độ phức tạp tính toán; nhưng trên thực tế thì tốc độ thực hiện thuật toán rất hiệu quả nhờ các tiến trình thực hiện độc lập được xử lý song song.Không dễ dàng để tăng tốc độ đối với các thuật toán tìm kiếm trên danh bạ. Thứ nhất, thuật toán tuần tự có độ phức tạp là logn và thứ hai là các tiến trình thực hiện các thao tác thường bị phụ thuộc lẫn nhau. Tuy nhiên, trong chương này đã mô tả thuật toán song song thực hiện các thao tác tìm kiếm, chèn và xóa trên máy tính đa bộ xử lý UMA. Các thuật toán đi kèm với các tiến trình với từng thao tác riêng lẻ được thể hiện. Việc khóa (lock) các tiến trình được sử dụng để khóa các tiến trình đan xen nhau tránh xung đột (contention) khi cần thiết. Thuật toán Ellis cho phép tìm kiếm và chèn vào cây AVL yêu cầu tiến trình thực hiện thao tác chèn phải khóa phần cây con mà có gốc là nút đang được quay (để bảo đảm tính cân bằng của cây. Thuật toán Manber và Ladner đòi hỏi không khóa nhiều hơn một nút trên cây đối với các thao tác: tìm kiếm, chèn, xóa và cập nhật. Các thuật toán song song yêu cầu độ phức thạp về thời gian không quá O(logn).

Hai thuật toán song song trên đồ thị nhằm giải quyết bài toán tìm đường đi ngắn nhất và cây khung nhỏ nhất được song song hóa từ các phiên bản tuần tự. Thuật toán Moore giải bài toán tìm đường đi ngắn nhất được song song hóa thành một giải thuật thực hiện trên máy tính đa xử lý UMA và dùng mảng liên kết để loại trừ các xung đột giữa các tiến trình. Mảng liên kết này có thể được thay thế bởi một hàng đợi hiệu quả hơn. Phiên bản song song của thuật toán Kruskal tìm cây khung nhỏ nhất cũng được thực hiện trên máy tính đa xử lý UMA. Thuật toán này hiệu quả đối với máy tính có ít bộ vi xử lý nhờ việc sử dụng kỹ thuật pipeline kết hợp với việc thao tác trên một heap.

2.8 Câu hỏi và bài tập

2.8.1 Câu hỏi

1. Trình bày về mô hình PRAM. Trong mô hình PRAM, một bộ xử lý có thể thực hiện được các thao tác gì?.

2. Nêu các cơ chế của mô hình PRAM giải quyết các vấn đề nhiều bộ xử lý đọc/ghi cùng một ô nhớ trong bộ nhớ toàn cục?.

3. Cho một ví dụ minh họa giải thuật trộn hai mảng đã sắp xếp thành một mảng được sắp xếp được trình bày ở phần 2.1.3.4. Trình bày thuật toán nhân hai ma trận trên máy SIMD với các bộ xử lý được tổ chức theo mạng hình lưới hai chiều.5. Trình bày thuật toán nhân hai ma trận trên máy SIMD với các bộ xử lý được tổ chức theo mạng siêu khối.6. Nêu ý nghĩa của thủ tục BIT.COMPLEMENT?. Cho ví dụ minh họa?.7. Trình bày thuật toán nhân hai ma trận trên máy đa bộ xử lý UMA?.8. Trình bày thuật toán nhân hai ma trận hướng khối trên hệ thống đa máy tính.9. Trình bày về giải thuật sắp xếp song song hoán chuyển chẵn lẻ: ý tưởng, thủ tục giả mã, độ phức tạp.10. Trình bày về giải thuật sắp xếp trộn Bitonic?.11. Chứng minh rằng: giải thuật sắp xếp Bitonic có độ phức tạp O(log2n). (gợi ý: T(n)=T(n/2)+O(logn)).12. Trình bày giải thuật sắp xếp Quicksort song song.13. Trình bày giải thuật sắp xếp siêu Quicksort.14. Hãy chỉ ra rằng: giải thuật Quicksort song song có độ phức tạp O(nlogn).15. Trình bày giải thuật song song Ellis trên máy tính đa bộ xử lý UMA?.16. Liệt kê và nêu ý nghĩa các thao tác cơ bản của thuật toán Manber và Ladner?.17. Sự khác nhau giữa tìm kiếm yếu và tìm kiếm mạnh trong thuật toán Manber và Ladner?18. Trình bày thuật toán song song tìm đường đi ngắn nhất trên máy tính đa bộ xử lý UMA?19. Trình bày thuật toán song song Sollin trên máy tính đa bộ xử lý UMA?20. Hãy chỉ ra rằng thuật toán song song Sollin trên máy tính đa bộ xử lý UMA có độ phức tạp O(n) với n là số cạnh của đồ thị đầu vào.

2.8.2 Bài tập

1. Hãy trình bày một thuật toán PRAM giải bài toán tính tổng của n số tự nhiên đầu tiên.2. Hãy trình bày một thuật toán PRAM giải bài toán tính tích phân sau:

I = 1

0

))(cos( dxxx

3. Hãy trình bày một thuật toán PRAM giải bài toán tìm tất cả các số nguyên tố nhỏ hơn số nguyên n cho trước.

4. Hãy mô tả từng bước của thuật toán nhân hai ma trận trên máy SIMD với các bộ xử lý được tổ chức theo mạng hình lưới hai chiều với đầu vào là hai ma trận sau:A= ( 2 3 4 1 1 0 1 1 2 1 4 1 1 0 3 4)và B= ( 1 0 0 1 2 1 0 0 0 1 1 2 1 0 3 0)

5. Hãy mô tả từng bước của thuật toán nhân hai ma trận trên máy SIMD với các bộ xử lý được tổ chức theo mạng hình siêu khối với đầu vào là hai ma trận A và B ở bài 4.

6. Mô tả từng bước thực hiện thuật toán hoán chuyển chẵn lẻ với đầu vào:{3 4 1 2 9 0 5 2 6}

7. Mô tả từng bước thực hiện thuật toán sắp xếp trộn Bitonic với đầu vào:{1 2 3 4 9 7 5 2 0}

8. Mô tả từng bước thực hiện thuật toán sắp xếp Quicksort song song với đầu vào:{3 4 1 2 9 0 5 2 6}

9. Mô tả từng bước thực hiện thuật toán sắp xếp siêu Quicksort với đầu vào:{3 4 1 2 9 0 5 2 6}

10. Hãy song song hóa giải thuật tìm kiếm nhị phân tuần tự?.

CHƯƠNG 3 : CÁC VẤN ĐỀ CỦA HỆ THỐNG TÍNH TOÁN SONG SONG

72131683 tinh toan song song

Documents