Phân tích must may để kiểm tra chương trình

ĐẠI HỌC QUỐC GIA TP. HỒ CHÍ MINH
TRƯỜNG ĐẠI HỌC BÁCH KHOA
-------------------

LÊ THỊ NHẬT VĂN

PHÂN TÍCH MUST-MAY
ĐỂ KIỂM TRA CHƯƠNG TRÌNH
Chun ngành: KHOA HỌC MÁY TÍNH

LUẬN VĂN THẠC SĨ
GVHD: TS. Quản Thành Thơ

TP. HỒ CHÍ MINH, tháng 07 năm 2012


1

CƠNG TRÌNH ĐƢỢC HỒN THÀNH TẠI
TRƢỜNG ĐẠI HỌC BÁCH KHOA
ĐẠI HỌC QUỐC GIA TP. HCM
Cán bộ hư ớng dẫn khoa học : TS. QUẢN THÀNH THƠ ......................................
..................................................................................................................................
Cán bộ chấm nhận xét 1 : .........................................................................................
..................................................................................................................................
Cán bộ chấm nhận xét 2 : .........................................................................................
..................................................................................................................................
Luận văn thạc sĩ được bảo vệ tại Trường Đại học Bách Khoa, ĐHQG Tp. HCM,
ngày . . . . . tháng . . . . năm 2012
Thành phần Hội đồng đánh giá luận văn thạc sĩ gồm:
(Ghi rõ họ, tên, học hàm, học vị của Hội đồng chấm bảo vệ luận văn thạc sĩ)

1. ...................................................
2. ...................................................
3. ...................................................
4. ...................................................
5. ...................................................
Xác nhận của Chủ tịch Hội đồng đánh giá LV và Trưởng Khoa quản lý chuyên
ngành sau khi luận văn đã được sửa chữa (nếu có).
Chủ tịch Hội đồng đánh giá LV

Phân tích MUST-MAY để kiểm tra chương trình

Trƣởng Khoa


2
ĐẠI HỌC QUỐC GIA TP.HCM
TRƢỜNG ĐẠI HỌC BÁCH KHOA

CỘNG HÒA XÃ HỘI CHỦ NGHĨA VIỆT
NAM Độc lập - Tự do - Hạnh phúc

NHIỆM VỤ LUẬN VĂN THẠC SĨ
Họ tên học viên: LÊ THỊ NHẬT VĂN ...................................... MSHV: 09070477 ..........
Ngày, tháng, năm sinh: 10/06/1984............................................ Nơi sinh: Đồng Nai.........
Chuyên ngành: Khoa học Máy Tính .......................................... Mã số : ......................

I. TÊN ĐỀ TÀI: Phân tích MUST-MAY để kiểm tra chương trình ..................................
.............................................................................................................................................
II. NHIỆM VỤ VÀ NỘI DUNG: ....................................................................................
Nhiệm vụ của luận văn : Nghiên cứu và xây dựng hệ thống sinh logic test-case dựa

trên kỹ thuật slicing cho những chương trình được viết bằng ngơn ngữ HIP.....................
Nội dung :
Tìm hiểu các kỹ thuật phân tích MUST và MAY và kết hợp 2 phương
pháp này để kiểm tra chương trình.
Tìm hiểu về separation logic và công cụ HIP/sleek - một công cụ hiệu
quả.để kiểm tra chương trình dựa trên con trỏ.
Tìm hiểu kỹ thuật concolic testing. Xây dựng một hệ thống sinh logic
test-case dựa trên kỹ thuật concolic testing cho chương trình dựa trên
con trỏ.
Tìm hiểu kỹ thuật slicing và áp dụng kỹ thuật slicing để hỗ trợ quá trình
phát hiện lỗi cũng như cải tiến quá trình sinh test-case của hệ thống.
III. NGÀY GIAO NHIỆM VỤ : 05/02/2011 ..................................................................

Phân tích MUST-MAY để kiểm tra chương trình


3

IV. NGÀY HOÀN THÀNH NHIỆM VỤ: 02/07/2012 ..................................................

V. CÁN BỘ HƢỚNG DẪN: TS. Quản Thành Thơ..........................................................
.............................................................................................................................................

Tp. HCM, ngày 02 tháng 07 năm 2012
CÁN BỘ HƢỚNG DẪN
(Họ tên và chữ ký)

CHỦ NHIỆM BỘ MÔN ĐÀO TẠO
(Họ tên và chữ ký)

TRƢỞNG KHOA….………
(Họ tên và chữ ký)

Phân tích MUST-MAY để kiểm tra chương trình


4

LỜI CẢM ƠN
Tôi xin chân thành cảm ơn TS. Quản Thành Thơ, người thầy đã tận tình
hướng dẫn tơi thực hiện đề tài này. Tôi xin chân thành cảm ơn thầy về những kiến
thức thầy đã truyền đạt cũng như sự quan tâm giúp đỡ của thầy trong quá trình tôi
thực hiện luận văn.
Xin chân thành cảm ơn quý thầy cơ Khoa Khoa học và Kỹ thuật Máy Tính
trường Đại học Bách Khoa Tp. HCM đã cung cấp cho tôi những kiến thức nền tảng
giúp tơi hồn thành luận văn.
Xin chân thành cảm ơn các tác giả của các tài liệu tham khảo được sử dụng
trong quá trình thực hiện đề tài.
Mặc dù có nhiều cố gắng tuy nhiên đề tài chắc chắn khơng thể tránh khỏi
những thiếu sót. Rất mong nhận được sự đóng góp, phê bình của q thầy cơ, bạn bè
để đề tài được hồn chỉnh hơn.

Tp. HCM, ngày 02 tháng 07 năm 2012

Phân tích MUST-MAY để kiểm tra chương trình


5

ABSTRACT

Testing based on test-case is still a primary way to check software bugs today.
White-box testing using program flow analysis currently is attracting much
attention in both industry and academic communities due to its capacity of
automatic test-case generation. To reduce the high cost of path exploration, the
concolic testing technique is recommended, which combines symbolic execution
with concrete execution during test-case generation process.
However, for heap-manipulation programs, where pointers are commonly used,
the test-cases generated by typical concolic approach are not sufficient to cover all
of necessary checking cases. The reason is that the concolic approach does not take
into account the specification of shared mutable data structures. Moreover, for large
programs, the cost for covering all the paths is very expensive. Thus, slicing
technique originally defined as program decomposition techniques based on
extracting statements relevant to a computation in a program is useful to deal with
this limitation. We don’t need to explore all the paths of program but still make sure
to generate the test-cases that cover all possible errors affecting a program's output.
In this research, taking advantage of the capacity of separation logic on
describing semantics of heap-based program, we develop a framework of slicingbased test-case generation on heap-manipulation programs. In doing so, we extend
the concolic approach by combining data specification with control flow when
symbolically executing the program. Slicing technique is combined on the fly to
lower the number of test-cases if could. The test-cases to be generated are
represented by separation formulae, thus regarded as logic test-case.

Phân tích MUST-MAY để kiểm tra chương trình


6

TÓM TẮT
Ngày nay, kiểm thử phần mềm dựa trên test-case là một kỹ thuật phổ biến
trong lĩnh vực kiểm tra phần mềm (software verification) để tìm lỗi trong chương

trình. Kỹ thuật kiểm tra hộp trắng (white-box testing) dựa trên việc phân tích luồng
thực thi của chương trình vẫn là cách được sử dụng chủ yếu trong môi trường giáo
dục cũng như cơng nghiệp. Tuy nhiên, kiểm tra hộp trắng có thể dẫn đến việc bùng
nổ trạng thái vì nó dựa vào số lệnh rẽ nhánh trong chương trình. Để khắc phục
nhược điểm này, kỹ thuật concolic testing được xem là một phương pháp hiệu quả
trong việc làm giảm số lần duyệt qua các đường thực thi của chương trình mà vẫn
đảm bảo sinh đủ test-case để phát hiện lỗi.
Tuy nhiên, đối với những chương trình thao tác trên heap, chủ yếu sử dụng
con trỏ, test-case sinh ra bởi kỹ thuật concolic testing không đảm bảo phủ tất cả các
trường hợp cần kiểm tra. Điều này là vì phương pháp này không sử dụng thông tin
về phần đặc tả cấu trúc dữ liệu để có thể kiểm tra tất cả các trường hợp xảy ra đối
với cấu trúc dữ liệu này.
Trong quá trình nghiên cứu, dựa vào ngữ nghĩa của separation logic áp dụng
cho việc suy luận cho những chương trình thao tác trên heap, đề tài đã đề xuất
phương pháp xây dựng một hệ thống sinh test-case hoàn chỉnh cho những chương
trình thao tác trên heap. Đề tài đã mở rộng kỹ thuật concolic testing bằng việc kết
hợp phần đặc tả cấu trúc dữ liệu từ chương trình nguồn với luồng thực thi (control
flow) của chương trình trong bước thực thi symbolic của kỹ thuật concolic testing.
Hơn nữa để cải tiến việc sinh ra số test-case hiệu quả cũng như hỗ trợ quá trình
debug phát hiện lỗi, hệ thống kết hợp kỹ thuật slicing đồng thời với quá trình sinh
test-case để xây dựng một hệ thống sinh test-case hoàn thiện hơn.

Phân tích MUST-MAY để kiểm tra chương trình


7

LỜI CAM ĐOAN
Tôi xin cam đoan luận văn tốt nghiệp này là cơng trình nghiên cứu thực sự của cá
nhân, được thực hiện trên cơ sở nghiên cứu lý thuyết và kiến thức của cá nhân dưới

sự hướng dẫn khoa học của TS. Quản Thành Thơ.
Các số liệu và những kết quả trong luận văn là trung thực, chưa từng được cơng bố
dưới bất cứ hình thức nào trước khi trình bảo vệ bởi Hội Đồng đánh giá luận văn tốt
nghiệp Thạc sĩ.
Một lần nữa, tôi xin khẳng định về sự trung thực của lời cam kết trên.

Phân tích MUST-MAY để kiểm tra chương trình


8

MỤC LỤC


NHIỆM VỤ LUẬN VĂN THẠC SĨ ....................................................................... 2
LỜI CẢM ƠN ......................................................................................................... 4
ABSTRACT ............................................................................................................ 5
TÓM TẮT ............................................................................................................... 6
LỜI CAM ĐOAN ................................................................................................... 7
MỤC LỤC ............................................................................................................... 8
MỤC LỤC BẢNG ................................................................................................ 11
MỤC LỤC HÌNH .................................................................................................. 12
Chƣơng 1 Giới thiệu ......................................................................................... 13
1.1

Tổng quan về đề tài ............................................................................... 13

1.2

Mục tiêu nghiên cứu của luận văn ....................................................... 15

1.3

Đóng góp của luận văn .......................................................................... 16

1.4

Cấu trúc của luận văn ........................................................................... 16

Chƣơng 2 Các kiến thức nền tảng ................................................................... 17
2.1

Separation logic...................................................................................... 17

2.1.1

Tổng quan về separation logic ....................................................... 17

2.1.2

Ngữ nghĩa của separation logic...................................................... 17

2.2

HIP .......................................................................................................... 26

2.2.1

Tổng quan về HIP ........................................................................... 26

2.2.2

Kiến trúc của hệ thống HIP ........................................................... 27

Phân tích MUST-MAY để kiểm tra chương trình


9
2.2.3

Ngôn ngữ đặc tả của HIP ............................................................... 28

2.2.4

Cơ chế kiểm tra tự động của HIP.................................................. 29

2.2.5

Mơ tả chƣơng trình input của HIP ............................................... 30

2.3

Kỹ thuật concolic testing ....................................................................... 34

2.4

Kỹ thuật slicing ...................................................................................... 36

2.4.1

Kỹ thuật static slicing ..................................................................... 36

2.4.2

Kỹ thuật dynamic slicing ................................................................ 38

2.4.3

Kỹ thuật relevant slicing ................................................................ 40

Chƣơng 3 Hệ thống sinh logic test-case dựa trên kỹ thuật slicing ............... 45
3.1

Các tiền đề .............................................................................................. 45

3.2

Hệ thống sinh logic test-case hoàn chỉnh ............................................. 48

Chƣơng 4 Cở sở lý thuyết của hệ thống sinh logic test-case dựa trên kỹ thuật
slicing
4.1

54
Các giải pháp cho cơ chế Slicing .......................................................... 54

4.1.1

Vấn đề bí danh ................................................................................ 55

4.1.2

Vấn đề khi truy xuất thuộc tính của cấu trúc dữ liệu ................. 57

4.2

Các giải pháp cho kỹ thuật sinh logic test-case................................... 58

4.2.1

Luật mở rộng (Expansion rules) ................................................... 59

4.2.2

Luật phục hồi test-case (Restoration rules) .................................. 62

Chƣơng 5 Hiện thực hệ thống sinh logic test-case dựa trên slicing ............. 64
5.1

Tổng quan về hệ thống .......................................................................... 64

5.2

Xây dựng các thành phần của hệ thống .............................................. 64

5.2.1

Module Slicing .................................................................................... 64

5.2.2

Module sinh test-case ......................................................................... 66

Phân tích MUST-MAY để kiểm tra chương trình


10
Chƣơng 6 Kết quả thực nghiệm và đánh giá ................................................. 68
6.1

Các điều kiện thử nghiệm ..................................................................... 68

6.2

Kết quả thử nghiệm ............................................................................... 68

Chƣơng 7 Tổng kết ........................................................................................... 70
7.1

Tổng kết .................................................................................................. 70

7.2

Hƣớng phát triển ................................................................................... 72

Tài liệu tham khảo .............................................................................................. 73

Phân tích MUST-MAY để kiểm tra chương trình

11

MỤC LỤC BẢNG

Bảng 2.1. Ví dụ minh họa cho concolic testing ................................................... 35
Bảng 2.2. Ví dụ minh họa cho PDG..................................................................... 37
Bảng 2.3: Ví dụ minh họa tập D/U của chương trình trong bảng 2.1 .................. 38
Bảng 2.4: Minh họa giải thuật Dynamic Slicing cho chương trình trong bảng 2.140
Bảng 2.5: Chương trình minh họa cho giải thuật Relevant Slicing ...................... 41
Bảng 2.6: Minh họa giải thuật Relevant Slicing cho chương trình trong bảng 2.543
Bảng 4.1: Minh họa quá trình slicing cho chương trình trong bảng 3.1 ............... 54
Bảng 4.2: Chương trình minh họa vấn đề bí danh ................................................ 55
Bảng 4.3: Minh họa quá trình slicing cho chương trình trong bảng 4.2 ............... 56
Bảng 4.4: Bảng lưu thơng tin bí danh trong chương trình .................................... 56
Bảng 4.5: Minh họa quá trình slicing có sử dụng thơng tin bí danh cho chương trình
trong bảng 4.2........................................................................................................ 56
Bảng 4.6: Minh họa quá trình slicing đúng đắn cho chương trình trong bảng 4.257
Bảng 4.7: Hàm thực hiện insert một node vào danh sách liên kết đơn ................. 58

Phân tích MUST-MAY để kiểm tra chương trình


12

MỤC LỤC HÌNH

Hình 2.1 : Mơ hình của separation logic (nguồn [12]).......................................... 18
Hình 2.2: Minh họa trạng thái chương trình qua các lệnh (nguồn [12]) ............... 19
Hình 2.3: Minh họa dùng separation logic để phát hiện lỗi chương trình
(nguồn [12]) .......................................................................................................... 20

Hình 2.4 : Các tiên đề áp dụng trên separation logic (nguồn [12]) ....................... 25
Hình 2.5: Kiến trúc của HIP (nguồn [16]) ............................................................ 27
Hình 2.6: Văn phạm của HIP định nghĩa core language (nguồn [16]) ................. 29
Hình 2.7: Forward rules (nguồn [16]) ................................................................... 30
Hình 2.8 : Đồ thị phụ thuộc chương trình (PDG) cho chương trình ở bảng 2.1 ... 37
Hình 2.9: Giải thuật Dynamic Slicing (nguồn [20]) ............................................. 40
Hình 2.10 . Minh họa phụ thuộc điều kiện............................................................ 42
Hình 2.11: Minh họa giải thuật Relevant Slicing (nguồn [20]) ............................ 43
Hình 3.1: Hệ thống sinh logic test-case dựa trên kỹ thuật slicing ........................ 48
Hình 4.1: Luật lưu trữ dữ liệu ............................................................................... 60
Hình 4.2: Luật thay thế.......................................................................................... 61
Hình 4.3: Luật đệ quy............................................................................................ 62
Hình 5.1: Hiện thực chi tiết module Slicing ......................................................... 65

Phân tích MUST-MAY để kiểm tra chương trình


13

Chƣơng 1

1.1

Giới thiệu

Tổng quan về đề tài
Ngày nay, trong lĩnh vực lập trình, lỗi chương trình là một thách thức lớn

cho các nhà phát triển phần mềm. Trên cơ sở đó, các cơng cụ khác nhau đã được
đề xuất để giúp đỡ các nhà phát triển phần mềm nhằm giúp giảm thiểu các lỗi

xảy ra trong chương trình.
Các cơng cụ kiểm tra phần mềm tự động xuất hiện ngày càng nhiều và có nhiều
đóng góp tích cực trong hướng kiểm tra phần mềm tự động. Các cơng cụ này có
thể được phân loại thành hai nhóm chính:
Nhóm đầu tiên là dựa trên kỹ thuật under-approximate hay còn được gọi là phân
tích MUST [1][2][3]. Phân tích MUST đảm bảo rằng thuộc tính (property) nào
đó của chương trình chắc chắn xảy ra trong một vài đường thực thi nào đó của
chương trình và có thể được sử dụng để chứng minh sự tồn tại lỗi trong chương
trình. Thuộc tính của chương trình biểu diễn cho một điều kiện lỗi nào đó trong
chương trình (ví dụ như lỗi tham khảo đến con trỏ null hoặc lỗi truy xuất chỉ số
phần tử của array vượt q kích thước khai báo của array đó,…). Để kiểm tra
chương trình có lỗi hay khơng, phải duyệt qua tất cả các đường thực thi của
chương trình, đối với các chương trình lớn, điều này là khơng khả thi, do đó các
thơng tin MUST khơng thể phủ được tất cả các đường thực thi có thể của
chương trình. Do đó, phân tích MUST khơng thể chứng minh chương trình
khơng có lỗi, vì vậy nhược điểm của phân tích MUST là gây ra tình trạng báo
lỗi false-negatives (tức là phân tích MUST sẽ báo là chương trình khơng có lỗi
dù thực sự chương trình có lỗi, vì như đã giải thích ở trên, phân tích MUST
khơng thể phủ tất cả các đường thực thi trong các chương trình lớn).

Phân tích MUST-MAY để kiểm tra chương trình


14
Nhóm thứ hai của các cơng cụ kiểm tra được dựa trên kỹ thuật overapproximate, còn được gọi là phân tích MAY [4][5][6]. Phân tích MAY dùng để
chứng minh một thuộc tính (property) nào đó của chương trình ln đúng đối
với tất cả các đường thực thi của chương trình. Phân tích MAY được sử dụng để
chứng minh chương trình khơng có lỗi. Vì áp dụng kỹ thuật over-approximate,
phân tích MAY có nhược điểm là gây ra tình trạng báo lỗi false-positives (tức là
phân tích MAY sẽ báo là chương trình có lỗi dù thực tế chương trình khơng có

lỗi). Nhược điểm này của phân tích MAY có thể làm cho các cơng cụ kiểm tra
chương trình trở nên khơng thực tế trong việc tìm kiếm và loại bỏ lỗi trong
chương

trình.

Gần đây, đã có nhiều cách tiếp cận mới để kết hợp các kỹ thuật underapproximate với các kỹ thuật over-approximate. Mục tiêu chính của việc kết hợp
các kỹ thuật khác nhau nhằm tăng độ chính xác và hiệu quả của các công cụ
kiểm tra phần mềm.
Ngày nay, kiểm thử phần mềm-một kỹ thuật phân tích MUST, dựa trên test-case
là một kỹ thuật phổ biến trong lĩnh vực phát triển phần mềm (software
development) [7][9][10][11] để tìm lỗi trong chương trình. Kỹ thuật kiểm tra
hộp trắng (white-box testing) [8] dựa trên việc phân tích luồng thực thi của
chương trình vẫn là cách được sử dụng chủ yếu trong môi trường giáo dục cũng
như công nghiệp. Tuy nhiên, kiểm tra hộp trắng có thể dẫn đến việc bùng nổ
trạng thái vì nó dựa vào số lệnh rẽ nhánh trong chương trình. Để khắc phục
nhược điểm này, kỹ thuật concolic testing được xem là một phương pháp hiệu
quả trong việc làm giảm số lần duyệt qua các đường thực thi của chương trình
mà vẫn đảm bảo sinh đủ test-case để phát hiện lỗi.
Tuy nhiên, đối với những chương trình thao tác trên heap, chủ yếu sử dụng
con trỏ, test-case sinh ra bởi kỹ thuật concolic testing không đảm bảo phủ tất cả các
trường hợp cần kiểm tra. Điều này là vì phương pháp này không sử dụng thông tin
về phần đặc tả cấu trúc dữ liệu để có thể kiểm tra tất cả các trường hợp xảy ra đối
Phân tích MUST-MAY để kiểm tra chương trình


15
với cấu trúc dữ liệu này.
Vì vậy, mục tiêu của đề tài là dựa vào ngữ nghĩa của separation logic áp dụng
cho việc suy luận cho những chương trình thao tác trên heap, đề xuất phương pháp

xây dựng một hệ thống sinh test-case hồn chỉnh cho những chương trình thao tác
trên heap. Đề tài mở rộng kỹ thuật concolic testing bằng việc kết hợp phần đặc tả
cấu trúc dữ liệu từ chương trình nguồn với luồng thực thi (control flow) của chương
trình trong bước thực thi symbolic của kỹ thuật concolic testing. Hơn nữa để cải tiến
việc sinh ra số test-case hiệu quả cũng như hỗ trợ quá trình debug phát hiện lỗi, hệ
thống kết hợp kỹ thuật slicing đồng thời với quá trình sinh test-case để xây dựng
một hệ thống sinh test-case hoàn thiện hơn.

1.2 Mục tiêu nghiên cứu của luận văn
Đề tài sẽ tập trung vào việc nghiên cứu các kỹ thuật kiểm tra chương trình
và xây dựng một hệ thống sinh logic test-case dựa trên kỹ thuật slicing cho
những chương trình được viết bằng ngơn ngữ HIP.
Nội dung chi tiết :
Tìm hiểu các kỹ thuật phân tích MUST và MAY và kết hợp 2 phương
pháp này để kiểm tra chương trình.
Tìm hiểu về separation logic và cơng cụ HIP/sleek - một công cụ hiệu
quả.để kiểm tra chương trình dựa trên con trỏ.
Tìm hiểu kỹ thuật concolic testing. Xây dựng một hệ thống sinh logic
test-case dựa trên kỹ thuật concolic testing cho chương trình dựa trên
con trỏ.
Tìm hiểu kỹ thuật slicing và áp dụng kỹ thuật slicing để hỗ trợ quá trình
phát hiện lỗi cũng như cải tiến quá trình sinh test-case của hệ thống.
Thử nghiệm, đánh giá và phân tích kỹ thuật đã phát triển để thấy được
ưu điểm và nhược điểm.

Phân tích MUST-MAY để kiểm tra chương trình


16

1.3

Đóng góp của luận văn
Luận văn đã hồn thành các mục tiêu đề ra, tìm hiểu các kỹ thuật kiểm tra

chương trình, từ đó xây dựng được một hệ thống sinh logic test-case cho những
chương trình thao tác trên con trỏ.
Đề tài tập trung nghiên cứu kỹ thuật phân tích MUST, mà điển hình là kỹ
thuật concolic testing, để phát hiện lỗi xảy ra trong chương trình (nếu có). Kết quả
của hệ thống sẽ là tập các test-case hiệu quả nhất (số lượng test-case là nhỏ nhất)
nhưng vẫn đảm bảo độ bao phủ các đường thực thi nhằm phát hiện lỗi trong chương
trình. Để thực hiện điều này, luận văn kết hợp kỹ thuật slicing để hỗ trợ quá trình
phát hiện lỗi cũng như cải tiến quá trình sinh test-case của hệ thống.
Trong quá trình hiện thực hệ thống, luận văn đã phát triển một tập luật để hỗ trợ quá
trình sinh test-case cho chương trình input được viết bằng ngơn ngữ HIP. Song song
đó, khi áp dụng kỹ thuật concolic testing trên những chương trình thao tác trên con
trỏ, luận văn cũng đề xuất cách khắc phục một số vấn đề thường xảy ra khi làm việc
với những chương trình có con trỏ, ví dụ như vấn đề bí danh và vấn đề truy xuất
thuộc tính của cấu trúc dữ liệu. Với những cải tiến này, tập slice trích xuất được sẽ
cho kết quả chính xác.
Trong q trình thực hiện, đề tài đã đóng góp được 1 bài báo nghiên cứu
được nói ở chương 7.

1.4

Cấu trúc của luận văn

Luận văn bao gồm 7 chương và được trình bày như sau:
Chương 1: Tổng quan về đề tài
Chương 2: Các kiến thức nền tảng

Chương 3: Hệ thống sinh test-case hoàn chỉnh
Chương 4: Các giải pháp cho hệ thống sinh test-case
Chương 5: Hiện thực hệ thống sinh test-case hoàn chỉnh
Chương 6: Kết quả thực nghiệm và Đánh giá
Chương 7: Kết luận và hướng phát triển
Phân tích MUST-MAY để kiểm tra chương trình


17

Chƣơng 2

Các kiến thức nền tảng

2.1

Separation logic

2.1.1

Tổng quan về separation logic

Separation logic [12][13] là logic mở rộng của Hoare logic [14], được dùng
để suy diễn cho chương trình sử dụng cấu trúc dữ liệu chia sẻ (mutable data
structure). Cấu trúc dữ liệu chia sẻ, tức cấu trúc mà một thuộc tính của nó có thể
được tham khảo từ nhiều hơn một con trỏ, thường xảy ra vấn đề bí danh. Đây là
một vấn đề gây khó khăn trong việc kiểm tra tính đúng đắn của chương trình.
Chúng ta khơng thể sử dụng Hoare logic để kiểm tra chương trình có chứa các
con trỏ vì có thể xảy ra vấn đề bí danh.

Vì vậy, Peter O'Hearn-Đại học London và John Reynolds-Đại học Carnegie
Mello đã phát triển separation logic từ Hoare logic bằng cách thêm 2 toán tử
mới: spatial conjunction (*) và spatial implication (-*) và một số tiên đề trên
separation logic giúp cho việc chứng minh những chương trình có chứa con trỏ.

2.1.2 Ngữ nghĩa của separation logic
2.1.2.1

Mơ hình biểu diễn của separation logic

Đối với Hoare logic, trạng thái của chương trình được biểu diễn bằng một
ánh xạ đi từ tên biến đến miền giá trị Integer (biểu diễn giá trị của biến đó) và được
gọi là Store.
StoresV

V

Integers

trong đó:
+ V: tập các biến
+ Integers: tập các số nguyên biểu diễn giá trị của biến
Tuy nhiên, đối với các chương trình có chứa con trỏ, với cách biểu diễn này ta
không thể biểu diễn được trường hợp bí danh (tức 2 con trỏ cùng trỏ đến một địa chỉ
Phân tích MUST-MAY để kiểm tra chương trình


18
bộ nhớ). Vì vậy, separation logic đề xuất thêm thành phần thứ 2 là heap. Mơ hình
của separtion logic sẽ có 2 thành phần: store và heap. Khái niệm store tương tự như

khái niệm của stack trong ngôn ngữ lập trình, chức năng của nó là ánh xạ từ các
biến đến miền giá trị số nguyên (miền số nguyên này biểu diễn địa chỉ mà biến đó
trỏ đến). Heap là ánh xạ đi từ miền địa chỉ ô nhớ (miền này là tập con của miền số
nguyên) đến miền số nguyên (biểu diễn giá trị của ô nhớ). Trạng thái của chương
trình lúc này sẽ được biểu diễn bằng 2 thành phần (Store x Heap).

Hình 2.1 : Mơ hình của separation logic (nguồn [12])

• Ints là miền các số nguyên
• Variables là miền các biến trong chương trình
• Atoms và Locations là tập con của Ints.
• Stores là hàm ánh xạ từ biến sang Ints
• Heap là ánh xạ từ Location sang Ints.
• States: biểu diễn trạng thái của chương trình được xác định bởi các cặp (Stores x
Heaps).
Với mơ hình này, separation logic có thể biểu diễn các lệnh như cấp phát bộ nhớ,
truy xuất, thay đổi giá trị ô nhớ, cũng như hủy bộ nhớ trong các chương trình có
chứa con trỏ.
Ví dụ 2.1: Trạng thái của chương trình có thể được biểu diễn bằng separation logic
qua các lệnh cấp phát, truy xuất, thay đổi giá trị ô nhớ và hủy ơ nhớ.

Phân tích MUST-MAY để kiểm tra chương trình


19

Hình 2.2: Minh họa trạng thái chương trình qua các lệnh (nguồn [12])

Ký hiệu [E] biểu diễn giá trị tại ô nhớ E.
Ở hình 2.2, giả sử chương trình ban đầu có 2 biến x và y trỏ đến 2 ô nhớ có địa chỉ

tương ứng là 3 và 4.
- Lệnh x := cons(1,2) khai báo biến x trỏ đến ô nhớ trong heap có giá trị là 1, và ô
nhớ tiếp theo ô nhớ này trong heap có giá trị là 2.
- Lệnh y := [x] gán biến y trỏ đến ơ nhớ có địa chỉ là nội dung của biến x
- Lệnh [x+1] := 3; thay đổi giá trị của ô nhớ tại địa chỉ x + 1
- Lệnh dispose(x+1): hủy ơ nhớ tại địa chỉ x+1
Ví dụ 2.2: Minh họa việc dùng separation logic để có thể phát hiện lỗi trong chương
trình, ở ví dụ này là lỗi truy xuất đến con trỏ null.

Phân tích MUST-MAY để kiểm tra chương trình


20

Hình 2.3: Minh họa dùng separation logic để phát hiện lỗi chương trình (nguồn [12])

2.1.2.2Các tốn tử của separation logic
Bên cạnh các toán tử được sử dụng trong Hoare logic, separation logic cung cấp
thêm một số toán tử sau để thuận tiện trong việc biểu diễn heap.
emp: biểu diễn một heap rỗng
e  e’: heap chứa một ô nhớ duy nhất, tại địa chỉ e và có giá trị là e’.
p1 * p2 : heap được chia thành 2 phần heap không giao nhau là p1 và p2
p1 - * p2:
Như ta đã biết, Hoare logic chỉ có thể biểu diễn trạng thái của chương trình
thơng qua ánh xạ từ tên biến đến giá trị của biến đó trong các chương trình khơng
chứa con trỏ. Đối với các chương trình có chứa con trỏ, để biểu diễn trạng thái của
chương trình, Hoare logic khơng thể biểu diễn trường hợp một con trỏ đang trỏ đến
một ơ nhớ nào đó, như trong ví dụ 2.3. Separation logic đã đề xuất tốn tử  , e 
e’ biểu diễn cho con trỏ e đang trỏ đến một ơ nhớ có giá trị e’.

Ví dụ 2.3:
int * p = new int();
*p = 3;
Thứ hai là vấn đề bí danh, Hoare logic khơng thể biểu diễn được trường hợp các
Phân tích MUST-MAY để kiểm tra chương trình


21
con trỏ có trỏ đến cùng một địa chỉ bộ nhớ hay khơng. Separation logic đã đề xuất
tốn tử *,
p1 * p2 biểu diễn 2 vùng nhớ heap là không giao nhau, lúc này sẽ khơng xảy ra vấn
đề bí danh.
Ví dụ 2.4: Minh họa cho trường hợp p và q trỏ đến 2 vùng nhớ khác nhau
int * p = new int();
int * q = new int();
*p = 3;
*q = 2;
Sau đây là một số ví dụ dùng separation logic để biểu diễn trạng thái của chương
trình
Ví dụ 2.5:
x  3, y : biểu diễn x trỏ đến 2 ô nhớ liên tục trong heap. Ô nhớ x trỏ đến có giá trị
là 3, ơ nhớ kế tiếp có giá trị là y (tức là, store ánh xạ x đến giá trị α và y đến giá trị β,
α là một địa chỉ, khi đó heap ánh xạ α đến giá trị là 3 và ánh xạ địa chỉ α + 1 đến giá
trị β)

Tương tự cho trường hợp

Ví dụ 2.6:
x  3, y y  3, x : cơng thức này có nghĩa là: 2 phần heap khơng giao nhau, phần
thứ nhất chứa 2 ô nhớ liên tục có giá trị lần lượt là 3 và y, và được trỏ đến bởi x,

phần thứ hai chứa 2 ô nhớ liên tục là 3 và x, và được trỏ đến bởi y.

Phân tích MUST-MAY để kiểm tra chương trình


22

Ví dụ 2.7:
x  3, y y  3, x: biểu diễn 2 heap giao nhau, tức x và y trỏ đến cùng một ơ nhớ

Bên cạnh đó, separation logic cịn rất hữu dụng trong việc mơ tả các cấu trúc
dữ liệu phức tạp. Để đặc tả chương trình một cách đầy đủ, cần phải mô tả nhiều hơn
về các hình thức cấu trúc của nó và mối quan hệ giữa các trạng thái của chương
trình đối với các giá trị trừu tượng mà chúng biểu thị. Cho ví dụ, để biểu diễn cấu
trúc danh sách trong separation logic, chúng ta có các định nghĩa sau, với α và β là
những chuỗi:
• ε là chuỗi rỗng
• [x] là một chuỗi một phần tử duy nhất chứa x
• α.β là một chuỗi tạo ra bằng cách thêm β vào α
• α + là một dạng nghịch đảo (reflection) của α
• # α là độ dài của α
• αi là phần tử thứ i trong chuỗi α
• list α(i, j) là một danh sách từ i tới j biểu diễn cho chuỗi α
Ví dụ 2.8: minh họa danh sách liên kết đơn

Chúng ta có thể định nghĩa bằng phương pháp quy nạp cho danh sách theo cấu trúc
Phân tích MUST-MAY để kiểm tra chương trình


23

của α như sau:
def

list (i,j)

emp i=j
def

list a

(i, j )

j.i  a , j list ( j, k ),

và sử dụng định nghĩa này để chứng minh một số thuộc tính cơ bản cho danh sách

i  a, j

list a (i, j )
list

(i, k )

list

b (i, k )

j. list (i, j ) list ( j , k )
j. list (i, j )

j  b,k

Ví dụ 2.9: minh họa xóa phần tử đầu tiên của một danh sách
{ list a

(i, k ) }

{ j. i  a, j list ( j , k ) }
{ i a

j. i 1  j list ( j , k ) }

j:=[i+1];
{ i  a i 1  j list ( j , k ) }
dispose i;
{i 1  j list ( j , k )}

dispose i+1;
{list ( j , k )}

i:=j
{list (i, k )}

Ngoài ra, separation logic cịn dung cho những chương trình phức tạp hơn như đảo
các phần tử của một danh sách
Ví dụ 2.10: minh họa chương trình đảo các phần tử của một danh sách (nguồn [12])

Phân tích MUST-MAY để kiểm tra chương trình

24

Ví dụ 2.11: Biểu diễn danh sách liên kết đơi (doubly-linked list) (nguồn [12])

dlist α(i, i’, j, j’) biểu diễn danh sách liên kết đôi cho chuỗi α từ i đến j, và từ j’
ngược về i’

Định nghĩa quy nạp cho danh sách liên kết đôi như sau:
dlist (i, i’, j, j’)
dlist a

def

emp i=j i’=j’

(i, i’, k, k’)

def

j. i  a, j, i’ dlist

Phân tích MUST-MAY để kiểm tra chương trình

(j, i, k, k’),