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

KHOA ĐÀO TẠO QUỐC TẾ VÀ SAU ĐẠI HỌC

---------------**********----------------

BÀI TIỂU LUẬNMôn: TÍNH TOÁN PHÂN TÁN

Chủ đề: “Thời gian logic”

Giáo viên giảng dạy: PGS.TS Trần Đình Quế

Nhóm thực hiện: Hoàng Thị Hà

Nguyễn Huyền Trang

Hoàng Hoài Nam

Phạm Đình Vũ

Lớp: Cao học Hệ thống thông tin 2013

Hà nội, ngày 28 tháng 3 năm 2014

MỤC LỤC

MỤC LỤC.....................................................................................................................1

NỘI DUNG...................................................................................................................2

Phần 1: GIỚI THIỆU....................................................................................................2

Phần 2: FRAMEWORK CHO HỆ THỐNG ĐỒNG HỒ LOGIC................................4

2.1 Định nghĩa...........................................................................................................4

2.2 Thực thi đồng hồ logic........................................................................................4

Phần 3: THỜI GIAN VÔ HƯỚNG...............................................................................6

3.1 Định nghĩa...........................................................................................................6

3.2 Các tính chất cơ bản............................................................................................6

Phần 4: VECTOR THỜI GIAN....................................................................................9

4.1 Một số định nghĩa về vector thời gian................................................................9

4.2 Ví dụ về tiến độ của các đồng hồ vector.............................................................9

4.3. Quan hệ nhân quả giữa hai sự kiện..................................................................10

4.4 Các tính chất của vector thời gian.....................................................................11

4.4.1 Tính đẳng cấu.............................................................................................11

4.4.2 Tính nhất quán mạnh..................................................................................11

4.4.3 Đếm sự kiện...............................................................................................11

Phần 5: THỰC HIỆN HIỆU QUẢ CỦA ĐÔNG HỒ VECTOR................................12

5.1 Phương pháp vi phân của Singhal-Kshemkalyani............................................12

5.2 Kỹ thuật phụ thuộc trực tiếp của Fowler – Zwaenepoel...................................14

Phần 6: KỸ THUẬT THÍCH ỨNG CỦA JARD – JOURDAN.................................18

Phần 7: MA TRẬN THỜI GIAN................................................................................22

NỘI DUNG

Phần 1: GIỚI THIỆUKhái niệm quan hệ nhân quả giữa các sự kiện là cơ sở để thiết kế và phân tích các hệ

hiều hành, tính toán phân tán và song song. Thông thường, quan hệ nhân quả được theo

dõi giám sát bởi thời gian vật lý. Sự cần thiết của thời gian logic xuất phát từ thực tế

trong các hệ thống phân tán, không thể có thời gian vật lý toàn cục, mà chỉ có thể nhận ra

một xấp xỉ của nó. Một thời gian logic, do đó không dựa trên đồng hồ nhưng có thể dựa

trên một giá trị thời gian thu được từ một cấu trúc dữ liệu hướng công thức. Khi một sự

kiện được thực hiện trong một quá trình, nó tính toán thời gian logic địa phương của

mình và gửi nó cùng với một thông điệp. Sự kiện bên nhận có được tri thức về thời gian

logic địa phương của các sự kiện trước đó mà nó có thể sử dụng để thiết lập thời gian

logic riêng của mình. Cơ chế này đảm bảo rằng các sự kiện được thực hiện theo đúng

trình tự. Chương này sẽ thảo luận 3 phương pháp để thực thi thời gian logic (ví dụ: thời

gian vô hướng, thời gian vectơ và thời gian ma trận) mà đã được đề xuất để phát hiện

quan hệ nhân quả giữa các sự kiện của tính toán phân tán.

Quan hệ nhân quả giữa các sự kiện trong một hệ thống phân tán là một định nghĩa

mạnh trong lập luận, phân tích, và suy luận tính toán. Tri thức về quan hệ nhân quả giữa

các sự kiện giúp cho việc giải quyết đa dạng các bài toán trong hệ phân tán. Ví dụ về một

số bài toán đó như sau:

- Thiết kế các thuật toán phân tán: tri thức về quan hệ nhân quả giữa các sự kiện

giúp đảm bảo tính tồn tại, và công bằng trong các thuật toán loại trừ, duy trì tính nhất

quán trong cơ sở dữ liệu nhân bản, và thiết kế các thuật toán phát hiện deadlock để tránh

phát hiện sai hoặc không phát hiện được deadlock.

- Theo dõi các sự kiện phụ thuộc: trong vấn đề gỡ lỗi phân tán, tri thức về sự phụ

thuộc nhân quả giữa các sự kiện giúp xây dựng nên một trạng thái nhất quán cho việc

khôi phục thực thi; trong quá trình phục hồi lỗi, nó giúp xây dựng một trạm kiểm soát;

trong cơ sở dữ liệu nhân bản, nó hỗ trợ phát hiện các mâu thuẫn tập tin trong trường hợp

phân vùng mạng

- Tri thức về tiến độ: tri thức về sự phụ thuộc nhân quả giữa các tiến trình giúp đo

được tiến độ của của các tiến trình trong tính toán phân tán. Điều này có ích trong việc

loại bỏ thông tin không dùng nữa (lỗi thời), thu gom rác và phát hiện kết thúc.

- Đo khả năng truy cập đồng thời: tri thức về số lượng sự kiện phụ thuộc nhân quả,

là có ích trong việc đo số lượng đồng thời trong tính toán phân tán. Tất cả các sự kiện mà

2

không phụ thuộc nhân quả có thể được thực thi đồng thời. Do vậy, một phép phân tích

nhân quả trong một tính toán phân tán cho ta ý tưởng về sự đồng thời trong chương trình.

Khái niệm nhân quả được con người sử dụng rộng rãi một cách vô thức, trong việc

lập kế hoạch, lập lịch, và thực hiện một việc, hoặc trong việc quyết định tính bất khả thi

của một kế hoạch. Trong cuộc sống hằng ngày, thời gian toàn cục để suy luận mối quan

hệ nhân quả thu được từ các đồng hồ đồng bộ hóa lỏng lẻo. Tuy nhiên trong hệ tính toán

phân tán, tỷ lệ xuất hiện các sự kiện là lớn hơn một vài đại lượng và thời gian thực thi các

sự kiện là nhỏ hơn một vài đại lượng. Do đó, nếu đồng hồ vật lý không được đồng bộ hóa

chặt chẽ thì quan hệ nhân quả giữa các sự kiện có thể không được chỉ ra chính xác. Các

giao thức thời gian mạng, NTP, mà có thể duy trì thời gian chính xác đến từng vài chục

mili giây trên Internet, vẫn không đủ để bắt được quan hệ nhân quả trong các hệ phân tán.

Tuy nhiên, trong tính toán phân tán, tiến độ thông thường được đẩy nhanh, và tương tác

giữa các tiến trình xảy ra cũng nhanh hơn. Do đó, trong một tính toán phân tán, quan hệ

nhân quả giữa các sự kiện được sinh ra bởi thực thi chương trình và tính chất đơn điệu cơ

bản của nó có thể đo được chính xác bởi các đồng hồ logic.

Trong một hệ thống đồng hồ logic, mọi tiến trình đều có 1 đồng hồ logic mà cải tiến

tập các quy tắc. Mỗi sự kiện được gán với một nhãn thời gian và quan hệ nhân quả giữa

các sự kiện có thể được suy ra từ nhãn thời gian của chúng. Các nhãn thời gian được gán

cho các sự kiện tuân theo tính chất đơn điệu cơ sở, đó là, nếu một sự kiện a ảnh hưởng

nhân quả tới sự kiện b thì nhãn thời gian của a nhỏ hơn nhãn thời gian của b.

Chương này đầu tiên giới thiệu một mô hình chung của hệ thống đồng hồ logic trong

các hệ thống phân tán, và sau đó thảo luận 3 cách để thực thi thời gian logic trong hệ

phân tán. Trong phương pháp thứ nhất, đồng hồ vô hướng Lamport, thời gian được biểu

diễn bởi các số nguyên không âm, ở phương pháp thứ hai, thời gian được biểu diễn bởi

một vecto các số nguyên không âm, phương pháp thứ 3, thời gian được biểu diễn bởi một

ma trận các số nguyên không âm. Chúng tôi cũng thảo luận các phương pháp hiệu quả để

thực hiện các hệ thống đồng hồ vectơ.

Chương này kết thúc bằng một thảo luận về thời gian ảo, sự thực hiện của nó sử dụng

cơ chế thời gian dọc, và thảo luận ngắn gọn về đồng bộ hóa đồng hồ vật lý và giao thức

thời gian mạng NTP.

3

Phần 2: FRAMEWORK CHO HỆ THỐNG ĐỒNG HỒ LOGIC

2.1 Định nghĩa

Một hệ thống đồng hồ logic bao gồm một miền thời gian T và đồng hồ logic C. Các

phần tử của T tạo thành một tập có thứ tự từng phần trên quan hệ < . Quan hệ này thường

được gọi là xảy ra trước hoặc quan hệ nhân quả. Đồng hồ logic C là một hàm mà ánh xạ

một sự kiện e trong hệ phân tán tới một phần tử trong miền thời gian T, ký hiệu là C(e) và

được gọi là nhãn thời gian của e, được định nghĩa như sau:

C: H→T, sao cho tính chất sau được thỏa mãn:

với hai sự kiện ei và ej , ei →ej⇒ C(ei) < C(ej).

Tính chất đơn điệu (monotonicity )này được gọi là điều kiện nhất quán đồng hồ. Khi

T và C thỏa mãn điều kiện sau:

với hai sự kiện ei và ej , ei →ej⇔ C(ei) < C(ej),

hệ thống đồng hồ được gọi là nhất quán mạnh.

2.2 Thực thi đồng hồ logic

Thực thi đồng hồ logic yêu cầu giải quyết hai vấn đề: cấu trúc dữ liệu địa phương tới

mọi tiến trình để biểu diễn thời gian logic và một giao thức (tập các quy tắc) để cập nhật

các cấu trúc dữ liệu để đảm bảo điều kiện nhất quán. Mỗi tiến trình pi duy trì các cấu trúc

dữ liệu mà cho phép hai khả năng sau:

• Một đồng hồ logic địa phương, ký hiệu bởi lci mà giúp tiến trình pi đo được tiến độ

của nó.

• Một đồng hồ logic toàn cục, ký hiệu gci là một biểu diễn địa phương tiến trình pi

của thời gian logic toàn cục. Nó cho phép tiến trình này gán những nhãn thời gian nhất

quán lên các sự kiện địa phương của nó. Thông thường, lci là một bộ phận của gci

Giao thức đảm bảo rằng một đồng hồ logic của tiến trình được quản lý nhất quán.

Giao thức bao gồm hai quy tắc sau:

• R1 Quy tắc này điều chỉnh cách thức để đồng hồ logic địa phương được cập nhật

bởi một tiến trình khi nó thực thi một sự kiện (gửi, nhận, hoặc internal).

• R2 Quy tắc này điều chỉnh cách thức một tiến trình cập nhật đồng hồ logic toàn cục

để để cập nhật biểu diễn của nó về thời gian toàn cục và tiến độ toàn cục. Nó yêu cầu

những thông tin nào về thời gian logic được mang theo trong thông điệp và cách thức

thông tin này được sử dụng bởi các tiến trình nhận để cập nhật biểu diễn thời gian toàn

cục của nó.

4

Hệ thống đồng hồ logic phân biệt nhau bởi biểu diễn thời gian logic của chúng và

giao thức cập nhật đồng hồ logic. Tuy nhiên, tất cả các hệ thống đồng hồ logic đều thực

hiện quy tắc R1 và R2 và do đó đảm bảo tính đơn điệu cơ sở kết hợp với quan hệ nhân

quả. Hơn nữa, mỗi hệ thống đồng hồ logic cụ thể còn cung cấp cho người dùng một vài

tính năng bổ sung.

5

Phần 3: THỜI GIAN VÔ HƯỚNG

3.1 Định nghĩa

Biểu diễn thời gian vô hướng được đề xuất bởi Lamport năm 1978, là một nỗ lực để

sắp thứ tự các sự kiện trong hệ phân tán. Miền thời gian trong biểu diễn này là tập các số

nguyên không âm. Đồng hồ logic địa phương của tiến trình pi và biểu diễn địa phương

của thời gian toàn cục được ép thành 1 biến nguyên Ci

Các quy tắc R1 và R2 cập nhật đồng hồ như sau:

• R1 trước khi thực thi sự kiện (send, receive, or internal), tiến trình pi thực hiện như

sau:

Ci :=Ci+d (d>0)

Nói chung, mỗi lần R1 được thực thi, d có thể có 1 giá trị khác nhau, và giá trị này có

thể phụ thuộc ứng dụng. Tuy nhiên, d thường bằng 1 vì điều này có thể xác định được

thời gian mỗi sự kiện ở duy nhất1 tiến trình, trong khi giữ tốc độ tăng của d ở mức thấp

nhất.

• R2 mỗi thông điệp mang theo giá trị đồng hồ của bên gửi nó ở thời điểm gửi. Khi

một tiến trình pi nhận một thông điệp với nhãn thời gian Cmsg, nó thực thi những hành

động sau đây:

1.Ci:=max ( Ci, Cmsg);

2. thực hiện R1;

3. chuyển thông điệp.

Hình 3.1 cho thấy sự phát triển của thời gian vô hướng với d= 1.

3.2 Các tính chất cơ bản

Tính nhất quán

6

Rõ ràng, các đồng hồ vô hướng thỏa mãn tính chất đơn điệu và do đó thỏa mãn tính

nhất quán:

với hai sự kiện ei và ej , ei →ej⇒ C(ei) < C(ej).

Sắp thứ tự toàn phần

Các đồng hồ vô hướng có thể được dùng để sắp thứ tự toàn bộ các sự kiện trong hệ

phân tán. Vấn đề chính trong các sự kiện được sắp thứ tự toàn phần đó là có nhiều hơn

hoặc hai sự kiện ở các tiến trình khác nhau cùng có 1 nhãn thời gian giống hệt nhau. (Chú

ý rằng đối với hai sự kiện e1và e2, C(e1) =C(e2) ⇒e1|| e2). Ví dụ, trong hình 3.1, sự kiện

thứ 3 của tiến tình P1 và sự kiện thứ 2 của tiến trình P2 có cùng nhãn thời gian vô hướng.

Do đó, một cơ chế phá vỡ ràng buộc là cần thiết để sắp xếp các sự kiện như vậy.

Thông thường, một ràng buộc được phá vỡ như sau: bộ nhận dạng tiến trình được sắp thứ

tự tuyến tính và một ràng buộc giữa các sự kiện với nhãn thời gian vô hướng xác định

được phá vỡ trên cơ sở nhận dạng tiến trình. Nhận dạng tiến trình thấp hơn trong bảng

xếp hạng, sẽ có độ ưu tiên cao hơn.

Nhãn thời gian của một sự kiện được ký hiệu bởi bộ (t, i), trong đó t là thời gian xuất

hiện và i là đặc tính của tiến trình nơi nó xảy ra. Quan hệ thứ tự toàn phần < trên hai sự

kiện x và y với nhãn thời gian (h,i) và (h,j) tương ứng, được định nghĩa như sau:

x ≺y⇔ (h<k or ( h=k and i < j))

Bởi vì các sự kiện xảy ra ở cùng một thời gian vô hướng logic là độc lập (nghĩa là

chúng không có quan hệ nhân quả) chúng có thể được sắp xếp sử dụng bất cứ tiêu chuẩn

tùy ý nào mà không vi phạm quan hệ nhân quả →. Do vậy, một thứ tự toàn phần là nhất

quán với quan hệ nhân quả “→”. Chú ý rằng x≺y⇒x→y∨x || y.Một thứ tự toàn phần nói

chung thường được đảm bảo tính chất tồn tại trong các thuật toán phân tán. Các yêu cầu

được gán nhãn thời gian và được phục vụ theo thứ tự toàn phần dựa trên những nhãn thời

gian này.

Đếm sự kiện

Nếu giá trị tăng d luôn luôn bằng 1, thời gian vô hướng có tính chất thú vị sau đây:

nếu sự kiện e có một nhãn thời gian h thì h-1 biểu diễn thời gian logic tối thiểu, được tính

toán bằng số đơn vị sự kiện, được yêu cầu trước khi sản sinh sự kiện e. Nói cách khác, h-

1 sự kiện đã được sản xuất tuần tự trước sự kiện e không liên quan tới các tiến trình sản

xuất các sự kiện này. Ví dụ, trong hình 3.1, 5 sự kiện trước b, là đường dẫn nhân quả dài

nhất kết thúc tại b.

Không nhất quán mạnh

7

Hệ thống đồng hồ vô hướng là không đồng nhất mạnh, đó là

với hai tiến trình ei và ej,C(ei)<C(ej) !⇒ei →ej

Ví dụ, trong hình 3.1, sự kiện thứ 3của tiến trình P1 có nhãn thời gian nhỏ hơn sự

kiện thứ 3 của tiến trình P2.Tuy nhiên, sự kiện đầu đã không xảy ra trước sự kiện sau. Lý

do mà các đồng hồ vô hướng là không nhất quán mạnh đó là đồng hồ logic địa phương và

đồng hồ logic toàn cục của một tiến trình được ghép thành một, kết quả là thông tin quan

hệ nhân quả bị mất giữa các sự kiện của các tiến trình khác nhau. Ví dụ: trong hình 3.1,

khi tiến trình P2 nhận thông điệp đầu tiên từ tiến trình P1, nó cập nhật đồng hồ tới 3,

quên mất rằng nhãn thời gian của sự kiện sớm nhất trong P1 mà nó phụ thuộc là 2.

8

Phần 4: VECTOR THỜI GIAN

4.1 Một số định nghĩa về vector thời gian

Hệ thống đồng hồ vector được Fidge, Mattern và Schmuck đề xuất.

• Trong hệ thống đồng hồ vector, miền thời gian tượng trưng bởi 1 tập hợp các

vector nguyên, không âm, n chiều.

• Mỗi tiến trình pi duy trì một vector vti[1..n], mà vti[i] là đồng hồ logic cục bộ của pi

và mô tả tiến độ thời gian logic tại tiến trình pi.

• vti[j] thể hiện cho việc nhận biết mới nhất của tiến trình pi về thời gian cục bộ tiến

trình pj.

• Nếu vti[j] = x, thì tiến trình pi biết rằng thời gian cục bộ tại tiến trình pj đã tiến triển

tới x.

• Toàn bộ các vector vti thiết lập quan sát của pi về thời gian logic toàn cục và được

sử dụng để đánh nhãn thời gian các sự kiện.

• Nhãn thời gian của một sự kiện là giá trị của đồng hồ vector tiến trình của nó khi

sự kiện được thực thi.

Tiến trình pi sử dụng 2 luật R1 và R2 để cập nhật đồng hồ của nó:

• R1: Trước khi thực thi một sự kiện, tiến trình pi cập nhật thời gian logic cục bộ

của nó như sau: vti[i] := vti[i] + d (d > 0)

• R2: Mỗi thông điệp m mang theo đồng hồ vector vt của tiến trình gửi tại thời gian

gửi. Nhận được thông điệp (m,vt), tiến trình pi thực thi theo trình tự sau:

– Cập nhật thời gian logic toàn cục của nó như sau:

1 ≤ k ≤ n : vti[k] := max(vti[k], vt[k]);

– Thực thi R1.

– Truyền thông điệp m.

4.2 Ví dụ về tiến độ của các đồng hồ vector

Quy tắc được áp dụng như sau:

1. Mọi vector khởi tạo có giá trị 0 tại mỗi tiến trình:

vti[j] = 0 với i, j = 1, ..., n

2. Những số gia tiến trình nguyên tố của các vector trong vector địa phương xảy ra

trước khi sự kiện gán nhãn thời gian:

vti[i] = vti[i] + 19

3. Thông điệp được gửi từ tiến trình pi gắn liền với vti tương ứng

4. Khi pj nhận được thông điệp, so sánh vector thành phần theo từng nguyên tố và

thiết lập vector địa phương:

vtj[i] = max (vti[i], vtj[i]) với i = 1, ..., n

Xét ví dụ về tiến độ của các đồng hồ vector với giá trị tăng lên d=1.

Hình 2.1: Sự phát triển của vector thời gian

4.3. Quan hệ nhân quả giữa hai sự kiện

Việc xác lập quan hệ nhân quả giữa hai sự kiện e1 và e2 bất kỳ dựa trên những quy tắc

sau:

1. Nếu e1 và e2 cùng xảy ra trên một tiến trình pi thì e1 → e2 khi và chỉ khi Hi(e1) <

Hi(e2)

2. Nếu e1 là sự kiện gửi đi một thông điệp m và e2 là sự kiện nhận được chính thông

điệp đó thì e1 → e2

3. Nếu e1 và e2 xảy ra trên hai tiến trình pi và pj bất kỳ trong hệ thống, ta có: e1 → e2

tương đương Hi(e1) < Hj(e2)

4. Nếu e1, e2 có mối quan hệ e1 || e2 thì tương đương H(e1) || H(e2)

So sánh nhãn thời gian vector

Để so sánh 2 nhãn thời gian vector vh và vk ta có các mối quan hệ sau:

10

4.4 Các tính chất của vector thời gian

4.4.1 Tính đẳng cấu

Nếu các sự kiện trong một hệ thống phân tán được đánh nhãn thời gian sử dụng một

hệ thống đồng hồ vector, chúng ta có tính chất sau:

• Nếu 2 sự kiện x và y có nhãn thời gian vh và vk tương ứng, thì

Do đó, có một đẳng cấu giữa tập các sự kiện có thứ tự từng phần được tạo ra bởi

một phép tính toán phân tán và nhãn thời gian vector của chúng

• Nếu tiến trình mà ở đó một sự kiện xảy ra, các thử nghiệm để so sánh hai nhãn

thời gian có thể được đơn giản hóa như sau: nếu sự kiện x và y xảy ra tương ứng

tại tiến trình pi và pj và được gán nhãn thời gian vh và vk tương ứng, thì

4.4.2 Tính nhất quán mạnh

• Hệ thống các đồng hồ vector có tính nhất quán mạnh; do đó bằng cách kiểm tra

nhãn thời gian vector của 2 sự kiện, ta có thể xác định các sự kiện có quan hệ nhân

quả hay không.

• Tuy nhiên, Charron-Bost đã chỉ ra rằng số chiều của đồng hồ vector không thể nhỏ

hơn n ( tổng số tiến trình trong tính toán phân tán).

4.4.3 Đếm sự kiện

Nếu d = 1 trong luật R1, thì thành phần thứ i của đồng hồ vector tại tiến trình pi,

vti[i], biểu thị số sự kiện đã xảy ra tại pi cho đến thời điểm đó.

Vì vậy, nếu một sự kiện e có nhãn thời gian vh, vh[j] biểu thị số sự kiện được thực thi

bởi tiến trình pj có quan hệ nhân quả trước e. Rõ ràng, ∑vh[j] – 1 thể hiện tổng số các sự

kiện có quan hệ nhận quả trước e trong tính toán phân tán.

11

Phần 5: THỰC HIỆN HIỆU QUẢ CỦA ĐÔNG HỒ VECTORNếu số lượng các tiến trình trong một tính toán phân tán là lớn, thì đồng hồ vector sẽ

yêu cầu kèm thêm một lượng lớn thông tin trong các thông điệp nhằm phục vụ mục đích

của quá trình khuyếch tán thời gian và cập nhật đồng hồ. Chi phí thông điệp tăng tuyến

tính với số lượng tiến trình trong hệ thống và khi có đến hàng nghìn tiến trình trong hệ

thống, kích cỡ thông điệp trở lên rất lớn ngay cả khi chỉ có một vài sự kiện diễn ra trong

vài tiến trình. Phần này thảo luận đến các cách hiệu quả để duy trì đồng hồ vector, các

phương pháp cơ bản tương tự có thể dùng để thực hiện hiêu quả đồng hồ ma trận.

Charron-Bost đã chỉ ra [2] rằng nếu đồng hồ vector phải đáp ứng tính chất nhất quán

mạnh, thì nhìn chung nhãn vector thời gian phải có cỡ ít nhất phải là n, tất cả các tiến

trình. Do vậy, nhìn chung kích thước của một nhãn vector thời gian là số lượng tiến trình

liên quan trong tính toán phân tán; tuy nhiên, một vài sự tối ưu hóa có thể xảy ra và tiếp

theo chúng tôi sẽ thảo luận về các kĩ thuật thực hiện đồng hồ vector một cách hiệu quả.

5.1 Phương pháp vi phân của Singhal-Kshemkalyani

Phương pháp vi phân của Singhal-Kshemkalyani [25] dựa trên việc quan sát giữa

thông điệp gửi thành công đến các tiến trình tương tự, chỉ một vài thành phần của đồng

hồ vector có thể bị thay đổi trong quá trình gửi thông điệp. Điều này dễ xảy ra hớn khi số

lượng tiến trình lớn do chỉ một vài tiến trình sẽ tương tác với thường xuyên bằng cách gửi

các thông điệp. Trong kỹ thuật này, khi một tiến trình pi gửi một thông điệp đến một tiến

trình pj, nó chỉ kèm thêm những thành phần của đồng hồ vector khác với thông điệp cuối

cùng được gửi đến pj.

Kỹ thuật này hoạt động như sau: nếu các thành phần i1,i2,…,in của đồng hồ vector tại

pi thay đổi tương ứng thành v1,v2,…vn, kể từ thông điệp cuối cùng được gửi đến pj, thì

tiến trình pi kèm theo một nhãn thời gian theo dạng

{(i1,v1), (i2,v2),…(in1,vn1)}

cùng thông điệp tiếp theo tới pj. Khi pj nhận được thông điệp này, nó sẽ cập nhật

đồng hồ vector của nó như sau:

vti[ik] = max(vti[ik],vk) với k=1,2,…n1.

Như vậy, phương pháp này cắt giảm kích thước thông điệp, băng thông truyền và yêu

câu vùng đệm (để lưu giữ thông điệp). Trong trường hợp xấu nhất, mọi thành phần của

đồng hồ vector được cập nhật tại pi do thông điệp cuối cùng tới tiến trình p j, và thông

điệp tiếp theo từ pi đến pj sẽ cần mang nhãn vector thời gian hoàn chỉnh của kích cỡ n.

Tuy nhiên, thường thì kích thước của nhãn thời gian trên một thông điệp sẽ ít hơn n. Lưu

ý rằng kỹ thuật này yêu cầu mỗi tiến trình ghi nhớ nhãn vector thời gian trong thông điệp 12

cuối gửi đến mọi tiến trình khác. Thực thi trực tiếp việc này sẽ dẫn đến chi phí lưu trữ

O(n2) tại mỗi tiến trình. Kỹ thuật này còn yêu cầu các kênh giao tiếp theo FIFO cho việc

truyền (gửi) thông điệp.

Singhal và Kshemkalyani đã phát triển một kỹ thuật thông minh cắt giảm chi phí lưu

trữ này tại mỗi tiến trình xuống O(n). Kỹ thuật này hoạt động theo cách sau: tiến trình p i

duy trì hai vector bổ sung sau:

LSi[l…n] (lần gửi cuối cùng): LSi[j] thể hiện giá trị của vti[i] khi tiến trình pi

gửi đi thông điệp cuối cùng đến tiến trình pj.

LUi[l…n] (lần cập nhật cuối cùng): LUi[j] thể hiện giá trị của vti[j] khi tiến

trình pi cập nhật lần cuối thành phần vti[j].

Rõ ràng, LUi[i]=vti[i] tại mọi thời điểm và LUi[j] cần được cập nhật chỉ khi nhận

được một thông điệp khiến pi cập nhật thành phần vti[j]. Đồng thời, LSi[j] cần cập nhật

chỉ khi pi gửi một thông điệp đến pj. Kể từ lần giao tiếp cuối cùng từ pi đến pj, chỉ những

thành phần k của đồng hồ vector vti[k] thay đổi do LSi[j] < LUi[k]. Do đó, những thành

phần này chỉ cần gửi trong thông điệp từ pi tới pj. Khi pi gửi một thông điệp tới pj, nó chỉ

gửi một bộ dữ liệu,

{(x, vti [x])|LSi[j]<LUi[x]},

là nhãn vector thời gian đến pj, thay vì gửi một vector n thành phần trong một thông điệp.

Do vậy, vector nguyên với kích thước n không phải gửi cùng với thông điệp. Thay

vào đó, chỉ các thành phần trong đồng hồ vector đã thay đổi từ thông điệp cuối cùng gửi

tới tiến trình kia được gửi theo dạng {(p1, latest_value), (p2,latest_value),..}, trong đó pi

thể hiện rằng thành phần lần thứ pi của đồng hồ véc tơ đã thay đổi.

Phương pháp này được minh họa trong hình 3.4. Ví dụ, thông điệp thứ hai từ p 3 tới p2

(bao gồm một nhãn thời gian {(3,2)} thông báo tới p2 rằng thành phần thứ ba của đồng hồ

vector đã được điều chỉnh và giá trị mới là 2. Điều này là do tiến trình p 3 (được thể hiện

bởi thành phần thứ ba của vector) làm tăng giá trị đồng hồ từ 1 lên 2 kể từ thông điệp

cuối cùng gửi tới p2.

13

Chi phí duy trì đồng hồ vector trong hệ thống lớn có thể giảm đáng kể bằng kỹ thuật

này, đặc biệt nếu sự tương tác tiến trình diễn ra cục bột heo không gian và thời gian. Kỹ

thuật này sẽ trở nên có lợi trong nhiều ứng dụng bao gồm cả bộ nhớ chia sẻ phân tán

nhân quả, phát hiện bế tắc phân tán, thi hành loại trừ lẫn nhau và truyền thông cục bộ

điển hình được quan sát trong hệ thống phân tán.

5.2 Kỹ thuật phụ thuộc trực tiếp của Fowler – Zwaenepoel

Kỹ thuật phụ thuộc trực tiếp [6] Fowler – Zwaenepoel làm giảm kích thước của

thông điệp bằng cách chỉ truyền một giá trị vô hướng trong thông điệp. Không có đồng

hồ vector được duy trì tức thời (on-the-fly). Thay vào đó, một tiến trình chỉ duy trì thông

tin liên quan đến tính phụ thuộc trực tiếp đến các tiến trình khác. Một vectơ thời gian cho

một sự kiện, thể hiện cho tính phụ thuộc bắc cầu trên tiến trình khác, được xây dựng

ngoại tuyến từ một tìm kiếm đệ quy của thông tin phụ thuộc trực tiếp vào các tiến trình.

Mỗi tiến trình pi duy trì một vector phụ thuộc Di. Ban đầu, Di[j] = 0 với j = 1, …, n.

Di được cập nhật như sau:

1. Bất cứ khi nào một sự kiện xảy ra tại pi, Di[i] := Di[i]+1. Có nghĩa là, các thành

phần của vector tương ứng với thời gian cục bộ được tăng lên một.

2. Khi một tiến trình pi gửi một thông điệp tới tiến trình pj, nó mang (piggybacks)

giá trị cập nhật của Di[i] trong thông điệp.

3. Khi tiến trình pi nhận một thông điệp từ pj với giá trị piggybacks d, pi cập nhật

vector phụ thuộc của nó như sau: Di[j]:= max {Di[j],d}.

Do vậy, vector phụ thuộc Di chỉ phản ánh phụ thuộc trực tiếp. Tại bất cứ thời điểm

nào, Di[j] biểu thị số thứ tự của các sự kiện mới nhất trên tiến trình p j cái mà trực tiếp ảnh

14

hưởng đến trạng thái hiện tại. Lưu ý rằng sự kiện này có thể đứng trước sự kiện mới nhất

tại pj nào ảnh hưởng đến trạng thái hiện tại.

Hình 3.5 minh họa kỹ thuật Fowler – Zwaenepoel. Ví dụ, khi tiến trình p4 gửi một

thông điệp tới tiến trình p3, nó piggybacks một đại lượng vô hướng chỉ ra sự phụ thuộc

trực tiếp của p3 vào p4 bởi thông điệp này. Sau đó, tiến trình p3 sẽ gửi một thông điệp tới

tiến trình p2 piggybacking một đại lượng vô hướng để chỉ sự phụ thuộc trực tiếp của p2

vào p3 bởi thông điệp này. Bây giờ, tiến trình p2 trên thực tế gián tiếp phụ thuộc vào quá

trình p4 vì tiến trình p3 là phụ thuộc vào tiến trình p4. Tuy nhiên, tiến trình p2 không bao

giờ được biết về tính phụ thuộc gián tiếp của nó vào p4.

Như vậy mặc dù tính phụ thuộc trực tiếp được thông báo hợp lệ cho các tiến trình

tiếp nhận, phụ thuộc bắc cầu (gián tiếp) không được duy trì bởi phương pháp này. Chúng

chỉ có thể thu được bằng cách đệ quy tìm dấu vết các vectơ phụ thuộc trực tiếp của các sự

kiện không trực tuyến. Điều này liên quan đến việc tính toán chi phí và độ trễ.

Như vậy phương pháp này là lý tưởng chỉ cho những ứng dụng mà không đòi hỏi

tính toán tính phụ thuộc bắc cầu tức thì. Tổng phí tính toán đặc trưng của phương pháp

này làm cho nó phù hợp nhất cho các ứng dụng như điểm ngắt nhân quả và phục hồi tính

năng kiểm tra từng điểm không đồng bộ trong đó các tính toán của quan hệ phụ thuộc

nhân quả được thực hiện ngoại tuyến.

Kỹ thuật này giúp tiết kiệm đáng kể chi phí; chỉ có một đại lượng vô hướng

piggybacked trên mỗi thông điệp. Tuy nhiên, các vector phụ thuộc không thể hiện tính

phụ thuộc bắc cầu (tức là, một nhãn thời gian vector). Tính phụ thuộc bắc cầu (hoặc

nhãn thời gian vector) của một sự kiện thu được bằng cách đệ quy truy tìm các vectơ phụ

thuộc trực tiếp của tiến trình. Rõ ràng, điều này sẽ có chi phí và sẽ liên quan đến độ trễ.

Do đó, kỹ thuật này là không phù hợp với các ứng dụng yêu cầu tính toán nhãn vector

thời gian tức thì. Tuy nhiên, kỹ thuật này là lý tưởng cho các ứng dụng mà các tính toán

15

của quan hệ nhân quả phụ thuộc thực hiện ngoại tuyến (ví dụ, điểm ngắt nhân quả, phục

hồi không đồng bộ checkpointing).

Tính phụ thuộc bắc cầu có thể được xác định bằng cách kết hợp sự kiện phụ thuộc

trực tiếp của một sự kiện với sự phụ thuộc trực tiếp vào nó. Trong hình 3.5, sự kiện thứ

tư của tiến trình p3 phụ thuộc vào sự kiện đầu tiên của tiến trình p4 và sự kiện thứ tư của

tiến trình p2 phụ thuộc vào sự kiện thứ tư của tiến trình p3. Bằng cách kết hợp hai phụ

thuộc trực tiếp, có thể suy luận rằng sự kiện thứ tư của tiến trình p2 phụ thuộc vào sự kiện

đầu tiên của tiến trình p4. Cần hết sức lưu ý rằng nếu sự kiện ej tại tiến trình pj xảy ra

trước sự kiện ei tại tiến trình pi, thì tất cả các sự kiện từ e0 đến ej-1 trong tiến trình pj cũng

xảy ra trước ei. Do đó, ghi lại cho ei sự kiện mới nhất của tiến trình pj đã xảy ra trước ei là

đủ. Bằng cách này, mỗi sự kiện sẽ ghi lại sự phụ thuộc của nó vào các sự kiện mới nhất

trên mỗi tiến trình khác mà nó phụ thuộc vào và duy trì những sự kiện phụ thuộc riêng

của chúng. Kết hợp tất cả các phụ thuộc, các tập nguyên (tức là vector nguyên bản) của

một sự kiện cụ thể phụ thuộc vào các sự kiện có thể được xác định ngoại tuyến.

Tính toán ngoại tuyến của phụ thuộc bắc cầu có thể được thực hiện bằng cách sử

dụng một thuật toán đệ quy đề xuất trong [6] và được minh họa bằng một dạng thức có

sửa đổi trong thuật toán 3.1. DTV là vector theo dõi phụ thuộc có kích thước n (trong đó

n là số tiến trình) mà lẽ ra phải theo dõi tất cả các phụ thuộc quan hệ nhân quả của một sự

kiện cụ thể ei ở tiến trình pi. Các thuật toán sau đó cần phải được gọi là DependencyTrack

(i, Die[i] ). Các thuật toán khởi tạo DTV có giá trị nhãn thời gian ít nhất có thể là 0 cho tất

cả các thành phần trừ i mà giá trị được đặt cho Die[i]: với mọi k = 1, …,n và k i,

DTV[k] = 0 và DTV[i] = Die[i] .

Sau đó thuật toán gọi giải thuật VisitEvent đối với tiến trình pi và sự kiện ei.

VisitEvent kiểm tra tất cả các thành phần (1, …,n) của DTV và Die và nếu giá trị trong Di

e

là lớn hơn giá trị trong DTV tại thành phần đó, sau đó DTV giả định giá trị của D ie cho

thành phần đó. Điều này đảm bảo rằng sự kiện mới nhất trong tiến trình j mà e i đó phụ

thuộc vào được ghi lại trong DTV. VisitEvent được gọi đệ qui đối với tất cả các thành

phần mà mới được đưa vào trong DTV để các thông tin phụ thuộc mới nhất có thể được

theo dõi một cách chính xác.

Minh họa cho thuật toán theo dõi phụ thuộc đệ quy bằng cách theo dõi các phụ thuộc

của sự kiện thứ tư tại tiến trình p2. Các thuật toán được gọi là DependencyTrack (2 4).

DTV ban đầu được thiết lập là <0 4 0 0> bởi DependencyTrack. Sau đó nó gọi

VisitEvent(2 4). Các giá trị được tổ chức bởi D42 là < 1 4 4 0 >. Vì vậy, DTV lúc này

được cập nhật thành < 1 4 0 0 > và VisitEvent (1 1) được gọi.

16

Các giá trị được tổ chức bởi D11 là < 1 0 0 0 >. Vì khi không có thành phần nào là lớn

hơn các thành phần tương ứng trong DTV, thuật toán lặp lại. Một lần nữa các giá trị được

tổ chức bởi D24 được kiểm tra và ần này thành phần 3 được tìm thấy là trong D2

4 lớn hơn

DTV. Vì vậy, DTV được cập nhật thành < 1 4 4 0 > và VisiEvent(3 4) được gọi. Các giá

trị được tổ chức bởi D34 là < 0 0 4 1 >. Vì thành phần 4 của D3

4 lớn hơn của DTV, nó

được cập nhật thành < 1 4 4 1 > và VisitEvent(4 1) được gọi. Vì tất cả các thành phần đã

được kiểm tra, Visit(2,4) được giải phóng và DependencyTrack cũng vậy.

Kỹ thuật này có thể tiết kiệm đáng kể chi phí chỉ có một đại lượng vô hướng

piggybacked trên mỗi thông điệp. Một trong những yêu cầu quan trọng là một tiến trình

cập nhật và ghi lại vectơ phụ thuộc của nó sau khi nhận được một thông điệp và trước khi

gửi đi bất kỳ thông điệp nào. Ngoài ra, nếu sự kiện xảy ra thường xuyên, kỹ thuật này sẽ

cần ghi lại lịch sử của một số lớn các sự kiện.

17

Phần 6: KỸ THUẬT THÍCH ỨNG CỦA JARD – JOURDAN Kỹ thuật phụ thuộc trực tiếp Fowler–Zwaenepoel không cho phép các phụ thuộc

ngoại lấy được ở thời gian thực trong khi thực thi của các tiến trình. Ngoài ra, một tiến

trình phải theo dõi một sự kiện (ví dụ cập nhật hoặc lưu vector phụ thuộc của nó) sau khi

nhận một thông điệp nhưng trước khi gửi ra bất kỳ thông điệp nào. Mặt khác, trong quá

trình xây dựng lại một vector nhãn thời gian từ các vector phụ thuộc trực tiếp, tất cả các

phụ thuộc nguyên nhân sẽ không được lấy. Nếu các sự kiện xảy ra rất thường xuyên, kỹ

thuật này sẽ yêu cầu lưu lịch sử của số lượng lớn các sự kiện.

Kỹ thuật Jard–Jourdan [8], các sự kiện có thể được theo dõi một cách thích ứng trong

khi duy trì khả năng lấy được tất cả phụ thuộc của một sự kiện được theo dõi. (Theo dõi

một sự kiện có nghĩa là lưu thông tin về các phụ thuộc của nó). Phương pháp này sử dụng

ý tưởng là khi một sự kiện e được theo dõi lưu các phụ thuộc của nó, sau đó các sự kiện

tiếp theo có thể xác định các phụ thuộc thích ứng của nó là bộ các sự kiện mà chúng phụ

thuộc một cách gián tiếp bằng cách tạo việc sử dụng thông tin được lưu về e. Lý do là khi

một sự kiện e được theo dõi, thông tin về việc gửi và nhận các thông điệp được duy trì

bởi một tiến trình được lưu trong sự kiện đó và thông tin được duy trì bởi tiến trình được

đặt lại và cập nhật sau đó. Do đó, tiến trình lan truyền thông tin sau e, nó chỉ lan truyền

lịch sử các hoạt động xảy ra sau e. Sự kiện được theo dõi tiếp theo cũng trong cùng tiến

trình hoặc trong một tiến trình khác, sau đó sẽ phải thấy thông tin được lưu cho e biết về

các hoạt động mà xảy ra trước e. Phương pháp này vẫn không cho phép xác định toàn bộ

phụ thuộc nguyên nhân trong thời gian thực, nhưng tránh được vấn đề lưu lượng lớn lịch

sử được nhận ra khi sử dụng kỹ thuật phụ thuộc trực tiếp.

Để triển khai kỹ thuật lưu thông tin trong một sự kiện được quan sát và thiết lập lại

thông tin được quản lý bởi một tiến trình, Jard–Jourdan một quan hệ toán tử giả trực tiếp

<< trên các sự kiện của tính toán phân tán như sau:

Nếu các sự kiện ei và ej xảy ra ở các tiến trình pi và pj tương ứng, giả sử ei << ej nếu

tồn tại một đường dẫn thông điệp truyền tải bắt đầu sau e j trên pj và kết thúc trước ei trên

tiến trình ei như là không có sự kiện được theo dõi trên đường dẫn. Quan hệ này được gọi

là toán tử giả trực tiếp bởi vì sự kiện ei có thể phụ thuộc vào nhiều sự kiện không được

theo dõi trên đường dẫn, gọi là ue1, ue2, … uen đến lượt phụ thuộc vào sự kiện khác. Nếu

ei xảy ra sau uen, sau đó ei vẫn được xem như phụ thuộc trực tiếp vào ue1, ue2, … uen vì

các sự kiện này không được theo dõi là giả thiết sai lầm có sự phụ thuộc trực tiếp. Nếu sự

kiện khác ek xảy ra sau ei, sau đó các phụ thuộc ngoại của ek trên ue1, ue2, … uen có thể

được xác định bởi thông tin được lưu ở ei và ei có thể làm giống với ej.

18

Kỹ thuật được xử lý sử dụng cơ chế sau: đồng hồ vector bộ phận p_vti ở tiến trình pi

là danh sách các giá trị hữu hạn trên mẫu (j,v) chỉ ra rằng trạng thái hiện thời của P i là

phụ thuộc giả trên sự kiện trên tiến trình pj có số thự tự là v. Ban đầu, ở một tiến trình p i:

p_vti ={(i,0)}.

Cho p_vti = {(i1, v1), …,(i, v),…,(in, vn)} biểu thị đồng hồ vector bộ phận ở tiến trình

pi. Cho e_vti là biến lưu nhãn thời gian của sự kiện được theo dõi.

(i) Bất cứ khi nào một sự kiện được theo dõi ở tiến trình p i, nội dung của đồng hồ

vector bộ phận p_vti được truyền sang e_vti và p_vti được đặt lại và cập nhật

như sau:

e_vti = {(i1, v1), …,(i, v),…,(in, vn)}

p_vti = {(i, v+1)}

(ii) Khi tiến trình pj gửi một thông điệp tới pi, nó mang theo giá trị hiện thời của

p_vti trong thông điệp.

(iii) Khi pi nhận một thông điệp mang theo nhãn thời gian p_vt, pi cập nhật p_vti

như sự kết hợp sau: (cho p_vt = {(im1, vm1),…,(imk, vmk)} và p_vti = {(i1, v1),…

(il, vl)}:

Toàn bộ (imx, vmx) là (imx, .) không có mặt trong v_pti;

Toàn bộ (ix, vx) là (ix, .) không có mặt trong v_pt;

Toàn bộ (ix, max(vx, vmx)) cho tất cả (vx, .) mà có mặt trong v_pt và

p_vti.

19

Trong sơ đồ 3.6, eX_ptn biểu thị nhãn thời gian của sự kiện được theo dõi thứ X ở

tiến trình pn. Chẳng hạn, sự kiện 1 được theo dõi ở p4 được gán nhãn thời gian e1_pt4 =

{(4, 0), (5, 1)}; nhãn thời gian này hàm ý rằng tiền bối giả trực tiếp của sự kiện này được

nằm trong tiến trình p4 và p5 và tương ứng với sự kiện 0 được theo dõi ở tiến trình p4 và

sự kiện 1 được theo dõi ở p5. v_ptn biểu thị danh sách nhãn thời gian được thu thập bởi

một tiến trình pn. Ví dụ, chúng ta hãy xem xét v_pt3. Tiến trình p3 đầu tiên thu thập nhãn

thời gian của sự kiện zero (3, 0) bên trong v_pt3 và khi sự kiện 1 được theo dõi xảy ra, nó

truyền nội dung của nó tới e1_pt3, thiết lập lại danh sách của nó và cập nhật giá trị của nó

thành (3,1) là nhãn thời gian của sự kiện được theo dõi. Khi nó nhận thông điệp từ tiến

trình p2, nó bao gồm các phần tử đó mà không có mặt trong danh sách của nó, cụ thể là

(1, 0) và (2, 0) vào v_pt3. Một lần nữa, khi sự kiện 2 được theo dõi, nó thiết lập lại danh

sách của nó thành {(3, 2)} và truyền nội dung của nó vào e2_pt3 chứa {(1, 0), (2, 0), (3,

1)}. Nó có thể được xem là sự kiện 2 ở tiến trình p3 phụ thuộc trực tiếp vào sự kiện 0 trên

tiến trình p2 và sự kiện 1 trên tiến trình p3. Nhưng nó là phụ thuộc trực tiếp giả vào sự

kiện 0 ở tiến trình p1. Nó cũng phụ thuộc vào tiến trình 0 ở sự kiện p3 nhưng thông tin

phụ thuộc này lấy được bằng cách kiểm tra e1_pt3 lưu trong sự kiện được theo dõi. Do đó,

các phụ thuộc ngoại của sự kiện 2 ở tiến trình p3 có thể được tính toán bằng cách kiểm tra

các sự kiện được theo dõi trong e2_pt3. Nếu điều này được thực hiện đệ quy, sau đó tất cả

20

phụ thuộc nguyên nhân của sự kiện được theo dõi có thể lưu được. Nó cũng phù hợp để

theo dõi ở đây mà các phụ thuộc ngoại này không thể được xác định trực tuyến nhưng từ

log của các sự kiện.

Phương pháp này có thể giúp đảm bảo rằng danh sách mang theo trên thông điệp có

kích thước tối ưu. Nó cũng có thể giới hạn kích thước của danh sách bằng cách đưa vào

sự kiện giả được theo dõi. Nếu kích thước của danh sách bị giới hạn là k, sau đó khi nhãn

thời gian của các sự kiện k được thu thập trong danh sách, một sự kiện giả được theo dõi

có thể được đưa vào để nhận nội dung của danh sách. Điều này cho phép nhiều độ phức

tạp trong quản lý kích thước các thông điệp.

21

Phần 7: MA TRẬN THỜI GIAN

7.1. Đĩnh nghĩa

Trong một hệ thống các ma trận đồng hồ, thời gian được biểu diễn bởi một tập hợp

các ma trận n x n của các số nguyên không âm. Một tiến trình p i duy trì một ma trận

mti[1..n,1..n], trong đó:

mti[i,i] biểu thị đồng hồ logic cục bộ của pi và lưu vết diễn biến của tính toán ở

tiến trình pi;

mti[i,j] biểu thị tri thức cuối cùng mà tiến trình pi có về đồng hồ logic cục bộ,

mtj[j,j] của tiến trình pj (chú ý rằng dòng mti[i,.] không là thứ gì nhưng đồng

hồ vector vti[.] và biểu lộ toàn bộ thuộc tính của các đồng hồ vector);

mti[j,k] biểu diễn tri thức mà tiến trình pi có về tri thức cuối cùng mà pj có về

đồng hồ logic cục bộ, mtk[k,k] của pk.

Toàn bộ ma trận mti biểu thị cái nhìn cục bộ về thời gian logic toàn cục của p i. Ma

trận nhãn thời gian của một sự kiện là giá trị của ma trận đồng hồ của tiến trình khi sự

kiện được thực thi.

Tiến trình pi sử dụng các quy tắc R1 và R2 sau đây để cập nhật đồng hồ của nó:

R1: Trước khi thực hiện một sự kiện, tiến trình p i cập nhật thời gian logic cục

bộ của nó như sau:

mti[I,i] := mti[i,i] + d (d > 0)

R2: Mỗi thông điệp m mang theo ma trận thời gian mt. Khi p i nhận một thông

điệp như vậy (m,mt) từ một tiến trình pj. pi thực hiện tuần tự các hành động

sau đây:

(i) Cập nhật thời gian logic toàn cục như sau:

(a) 1 ≤ k ≤ n : mti[i,k] := max (mti[i,k], mt[j,k]), (đó là cập nhật dòng

mti[i,*] của nó với dòng của pj trong nhãn thời gian nhận được, mt);

(b) 1 ≤ k,l ≤ n : mti[k,l] := max (mti[k,l], mt[k,l]);

(ii) Thực hiện R1;

(iii) Phân phát thông điệp m.

22

Sơ đồ 3.7 cho một ví dụ minh họa các ma trận đồng hồ diễn biến trong tính toán phân

tán. Chúng ta giả sử d = 1. Chúng ta hãy xem xét các sự kiện sau: e là sự kiện thứ x i ở

tiến trình pi, ek1 và ek

2 là các sự kiện thứ xk1 và xk

2 ở tiến trình pk và ej1 và ej

2 là các sự kiện

thứ xj1 và xj

2 ở pj. Cho mte biểu diễn ma trận nhãn thời gian liên kết với sự kiện e. Do

thông điệp m4, ek2 là sự kiện cuối cùng của pk trước e về mặt nguyên nhân, do đó, chúng

ta có mte[i,k] = mte[k,k] = xk2. Tương tự, mte[i,j] = mte[j,j] = xj

2. Sự kiện cuối cùng của pk

được biết bởi pj, cho tri thức của pi khi nó thực hiện sự kiện e, là ek1; do đó mte[j,k] = xk

1.

Tương tự, chúng ta có mte[k,j] = xj1.

Một hệ thống ma trận đồng hồ là đề nghị không chính thức đầu tiên của Micheal và

Fischer [5] và được sử dụng bởi Wuu và Bernstain [28] và bởi Sarin và Lynch [22] để

loại bỏ các thông tin không dùng đến trong các cơ sở dữ liệu nhân bản.

7.2. Các thuộc tính cơ bản

Rõ ràng vector mti[i,.] chứa toàn bộ thuộc tính của đồng hồ vector. Ngoài ra, ma trận

đồng hồ có thuộc tính sau đây:

mink(mti[k,l] ≥ t => tiến trình pi biết rằng mỗi tiến trình pk khác biết rằng thời gian

cục bộ của pl được diễn biến cho tới t.

Nếu điều này là đúng, rõ ràng là tiến trình pi biết rằng tất cả các tiến trình khác biết

rằng pl sẽ không bao giờ gửi thông tin với thời gian cục bộ ≤ t. Trong nhiều ứng dụng,

điều này ngụ ý rằng các tiến trình sẽ không yêu cầu lâu hơn từ p l một vài thông tin và có

thể sử dụng thực tế này để bỏ qua các thông tin không dùng đến.

Nếu d luôn là 1 trong quy tắc R1, thì mt i[k,l] biểu thị số sựu kiện xảy ra ở p l và được

biết bởi pk cho tới tri thức của pi có liên quan.

23