An open and safe nested transaction model: Mӝt mӣ và an toàn mô hình giao dӏch lӗng Mô hình giao dӏch

h giao dӏch mӣ và an toàn lӗng nhau:

concurrency and recovery nhau: đӗng thӡi và phөc hӗi tương tranh và phөc hӗi
Abstract Tóm tҳt Tóm tҳt
In this paper, we present an open and safe Trong bài báo này, chúng tôi trình bày mӝt Trong bài báo này, chúng nӝi trình bày mӝt
nested transaction model. We discuss the mô hình giao dӏch mӣ và an toàn lӗng nhau. mô hình giao dӏch mӣ và an toàn kép. Chúng
concurrency control and recovery algorithms Chúng tôi thҧo luұn vӅ điӅu khiӇn tương tôi trình bày vӅ điӅu khiӇn tương tranh và các
for our model. Our nested transaction model tranh và các thuұt toán phөc hӗi cho các mô thuұt toán phөc hӗi cho mô hình này. Trong
uses the notion of a recovery point hình cӫa chúng tôi. mô hình giao dӏch lӗng mô hình giao dӏch lӗng nhau sӱ dөng khái
subtransaction in the nested transaction tree. nhau chúng tôi sӱ dөng khái niӋm vӅ mӝt niӋm giao điӇm giao dӏch phө phөc hӗi trong
It incorporates a prewrite operation before subtransaction điӇm khôi phөc trong cây giao cây giao dӏch lӗng nhau. Nó kӃt hӧp mӝt xӱ
each write operation to increase the potential dӏch lӗng nhau. Nó kӃt hӧp mӝt prewrite hoҥt lý prewrite trưӟc mӛi xӱ lý write đӇ tăng
concurrency. Our transaction model is termed đӝng trưӟc khi tӯng viӃt hoҥt đӝng đӇ tăng cưӡng tương tranh tiӅm năng. Mô hình giao
``open and safe'' as prewrites allow early tương tranh tiӅm năng. mô hình giao dӏch cӫa dӏch cӫa chúng tôi gӑi là ³mӣ và an toàn´
reads (before writes are performed on disk) chúng tôi đưӧc gӑi là "mӣ và an toàn''như như là ghi trưӟc cho phép đӑc (trưӟc khi
without cascading aborts. The systems restart prewrites cho phép đҫu đӑc (trưӟc khi viӃt hành đӝng writes đưӧc thӵc hiӋn trên đĩa) mà
and buffer management operations are also đưӧc thӵc hiӋn trên đĩa) mà không cҫn hӫy không cҫn tҫng hӫy bӓ. HӋ thӕng khӣi đӝng
modeled as nested transactions to exploit bӓ tҫng. Các hӋ thӕng khӣi đӝng lҥi và hoҥt và hoҥt đӝng quҧn lý bӝ đӋm cũng cũng đưӧc
possible concurrency during restart. The đӝng quҧn lý bӝ đӋm cũng đưӧc mô hình hóa mô hình hóa như các giao dӏch lӗng nhau đӇ
concurrency control algorithm proposed for như các giao dӏch lӗng nhau đӇ khai thác khai thác đӗng thӡi trong suӕt quá trình khӣi
database operations is also used to control đӗng thӡi có thӇ trong quá trình khӣi đӝng đӝng lҥi. Thuұt toán điӅu khiӇn tương tranh
concurrent recovery operations. We have lҥi. ViӋc tranh KiӇm soát thuұt toán đӅ xuҩt đӅ xuҩt cho xӱ lý cơ sӣ dũ liӋu cũng đưӧc xӱ
given a snapshot of complete transaction cho các hoҥt đӝng cơ sӣ dӳ liӋu cũng đưӧc sӱ dөng đӇ kiӇm soát các hoҥt đӝng phөc hӗi
processing, data structures involved and, dөng đӇ kiӇm soát các hoҥt đӝng phөc hӗi đӗng thӡi. Chúng tôi cung cҩp mӝt bҧn chөt
building the restart state in case of crash đӗng thӡi. Chúng tôi đã cung cҩp mӝt bҧn xӱ lý giao dӏch hoàn tҩt, cҩu trúc dӳ liӋu liên
recovery. Ó 2000 Elsevier Science Inc. All chөp xӱ lý giao dӏch hoàn tҩt, cҩu trúc dӳ quan và xây dӵng lҥi vùng trong trưӡng hӧp
rights reserved. liӋu liên quan và, xây dӵng khӣi đӝng lҥi nhà sөp đә.
nưӟc trong trưӡng hӧp phөc hӗi sөp đә. Ó
2000 Elsevier Science Inc.
Introduction 1, Giӟi thiӋu 1. Giӟi thiӋu
1.1. Overview of nested transaction models 1.1. Tәng quan các mô hình giao dӏch lӗng 1.1. Tәng quan mô hình giao dӏch lӗng nhau
and recovery algorithms nhau và các thuұt toán phөc hӗi và thuұt toán phөc hӗi
1.1.1 Close nested transaction model 1.1.1 Đóng mô hình giao dӏch lӗng nhau 1.1.1 mô hình giao dӏch lông nhau đóng
In close nested transaction model (Moss, Trong mô hình giao dӏch lӗng nhau gҫn Trong mô hình giao dӏch lӗng nhau đóng
1985), a subtransaction may contain (Moss, 1985), mӝt subtransaction có thӇ chӭa (Moss,1985), mӝt giao dӏch phө có thӇ chӭa
operations to be performed concurrently, or các hoҥt đӝng đưӧc thӵc hiӋn đӗng thӡi, hoһc Các hoҥt đӝng đưӧc thӵc hiӋn đӗng thӡi,
operations that may be aborted independent hoҥt đӝng có thӇ sӁ đưӧc hӫy bӓ đӝc lұp cӫa hoһc hoҥt đӝng có thӇ sӁ bӏ hӫy bӓ phө thuӝc
of their invoking transaction. Such operations
các giao dӏch cách gӑi cӫa hӑ. hoҥt đӝng này vào giao dӏch cӫa cӫa. Hoҥt đӝng này đưӧc
are considered as subtransactions of the đưӧc coi là subtransactions cӫa giao dӏch ban coi là giao dӏch phө cӫa giao dӏch ban đҫu.
original transaction. This parent±child đҫu. ĐiӅu này mӕi quan hӋ mҽ con ± de ® ĐiӅu này có mӕi quan hӋ
relationship de®nes a nested transaction tree
nes mӝt cây giao dӏch lӗng nhau và các giao
and transactions are termed as nested dӏch đưӧc gӑi là giao dӏch lӗng nhau (Moss,
transactions (Moss, 1985). Failure of 1985). Thҩt bҥi cӫa subtransactions có thӇ
subtransactions may result in the invocationdүn đӃn viӋc gӑi cӫa subtransactions thay thӃ
of alternate subtransactions that could replace
có thӇ thay thӃ nhӳng cái không thӇ thӵc hiӋn
the failed ones to accomplish the successfulđưӧc hoàn tҩt thành công cӫa toàn bӝ giao
completion of the whole transaction. Each dӏch. Mӛi giao dӏch đӇ có đưӧc các khóa
transaction has to acquire the respective lock
tương ӭng trưӟc khi truy cұp vào mӝt đӕi
before accessing a data object. A tưӧng dӳ liӋu. vv ¼ e cӫa A subtransaction
subtransaction's e¼ect cannot be seen outside
không thӇ nhìn thҩy bên ngoài cӫa phө huynh
its parent's view (hence, called closed). A xem nó (vì thӃ, đưӧc gӑi là đóng cӱa). Mӝt
child transaction has access to the data locked
giao dӏch trҿ đã truy cұp vào các dӳ liӋu bӏ
by its parent. When a transaction writes a khóa bӣi cha cӫa nó. Khi giao dӏch viӃt mӝt
data object, a new version of the object is đӕi tưӧng dӳ liӋu, mӝt phiên bҧn mӟi cӫa đӕi
created. This version of the object is stored in
tưӧng đưӧc tҥo ra. Đây là phiên bҧn cӫa đӕi
volatile memory. When the subtransaction tưӧng đưӧc lưu trӳ trong bӝ nhӟ әn đӏnh. Khi
commits, the updated versions of the object subtransaction các cam kӃt, các phiên bҧn
are passed to its parent. If the transactioncұp nhұt cӫa đӕi tưӧng đưӧc chuyӇn đӃn cha
aborts, the new version of the object is cӫa nó. NӃu hӫy bӓ giao dӏch, phiên bҧn mӟi
discarded. Parent commits only after all itscӫa đӕi tưӧng sӁ bӏ loҥi. Phө huynh cam kӃt
children are terminated. When the top-level chӍ sau khi tҩt cҧ các trҿ em đưӧc chҩm dӭt.
transaction commits, the current version of Khi cҩp trên cam kӃt giao dӏch, phiên bҧn
each object is saved on stable storage. hiӋn hành cӫa mӛi đӕi tưӧng đưӧc lưu trӳ әn
đӏnh.
In the closed nested transaction model, the Trong mô hình giao dӏch đóng cӱa lӗng nhau,
availability is restricted as the scope of each
subtransaction is restricted to its parent only.
This forces a subtransaction to pass all its
locks and versions of data objects updated to
its parent on commit. The e ect of a
committed subtransaction is made permanent
only when the toplevel transaction commits.
In many applications, it is unacceptable that
the work of a longlived transaction is
completely undone by using either of the
above techniques in case the transaction
eventually fails at ®nishing stage. The
current strategy forces short-lived
transactions to wait before they acquire locks
until the top-level transactions commit and
release their locks. Therefore, the model is
not appropriate for the system that consists of
long and short transactions.
1.1.2. Open nested transaction model
To exploit layer speci®c semantics at each level of
operation nesting, Weikum presented a multilevel
transaction model (Weikum, 1991; Weikum
et al., 1990). The model provides non-strict
execution by taking into account the
commutative properties of the semantics of
operations at each level of data bstraction,
which achieves a higher degree of
oncurrency. A subtransaction is allowed to
release locks before the commit of higher
level transactions. The leaf level locks are
released early only if the semantics of the
có bӏ hҥn chӃ là phҥm vi cӫa mӛi
subtransaction đưӧc giӟi hҥn chӍ có mҽ. ĐiӅu
này buӝc mӝt subtransaction đӇ vưӧt qua tҩt
cҧ các ә khóa và các phiên bҧn cӫa đӕi tưӧng
dӳ liӋu cұp nhұt đӇ cha mҽ cӫa nó trên cam
kӃt. Các ¼ e vv cӫa mӝt subtransaction cam
kӃt đưӧc thӵc hiӋn thưӡng xuyên khi các giao
dӏch cҩp đҫu cam kӃt. Trong nhiӅu ӭng dөng,
nó là không thӇ chҩp nhұn rҵng công viӋc cӫa
mӝt giao dӏch longlived là hoàn toàn hoàn tác
bҵng cách sӱ dөng mӝt trong các kӻ thuұt nói
trên trong trưӡng hӧp giao dӏch cuӕi cùng
thҩt bҥi ӣ giai đoҥn nishing ®. ChiӃn lưӧc
hiӋn nay lӵc lưӧng các giao dӏch ngҳn ngӫi
đӇ chӡ đӧi trưӟc khi hӑ có đưӧc ә khóa cho
đӃn khi cҩp trên giao dӏch cam kӃt và giҧi
phóng ә khóa cӫa hӑ. Vì vұy, mô hình không
thích hӧp cho các hӋ thӕng bao gӗm các giao
dӏch lâu dài và ngҳn.
1.1.2. Mӣ mô hình giao dӏch lӗng nhau
ĐӇ khai thác speci lӟp ngӳ nghĩa c ® tҥi mӛi
cҩp đӝ cӫa hoҥt đӝng làm tә, Weikum trình
bày mӝt mô hình giao dӏch đa (Weikum, năm
1991; Weikum và cӝng sӵ năm 1990.,) Ngӳ
nghĩa này. Mô hình không đúng quy đӏnh
thӵc hiӋn bӣi có tính giao hoán các thuӝc tính
cӫa hoҥt đӝng ӣ mӛi cҩp dӳ liӋu trӯu tưӧng,
mà đҥt đưӧc mӝt mӭc đӝ cao hơn cӫa tương
tranh. subtransaction A đưӧc phép phát hành
khóa trưӟc khi cam kӃt giao dӏch cҩp cao
hơn. Các khóa cҩp lá đưӧc phát hành sӟm
nӃu ngӳ nghĩa cӫa các hoҥt đӝng đưӧc biӃt
operations are known and the corresponding
compensatory actions de®ned. When a high
level transaction aborts, its e¼ect is undone
by executing an inverse action which
compensates the completed transaction.
Recovery from system crashes is provided by
executing undo actions at the upper levels
and redo actions at the leaf level. Each level
is provided with a level speci®c recovery
mechanism. This model has also been studied
in the framework of object oriented databases
in Muth et al. (1993) and Resende et al.
(1994).
In many applications, the semantics of transactions
may not be known and hence, it is di cult to provide
non-strict executions. In real time situations, there are
other classes of operations that cannot be
compensated. These are the operations that
have an irreversible external e¼ect, such as
handing over huge amounts of money at an
automatic teller machine. Such operations
have to be deferred until top-level commits,
which restricts availability (i.e., increases
response time).
1.1.3. Nested transaction recovery algorithms
đӃn và nhӳng hành đӝng đӅn bù tương ӭng
de ® ned. Khi mӝt giao dӏch sӁ ngӯng cҩp
cao, vv cӫa nó ¼ e là hoàn tác bҵng cách thӵc
hiӋn mӝt hành đӝng nghӏch đҧo mà đӅn bù
giao dӏch hoàn tҩt. Phөc hӗi tӯ hӋ thӕng treo
đưӧc cung cҩp bҵng cách thӵc hiӋn hoàn tác
hành đӝng ӣ cҩp trên và làm lҥi các hành
đӝng ӣ cҩp lá. Mӛi cҩp đӝ đưӧc cung cҩp vӟi
mӝt speci ® c cҩp cơ chӃ phөc hӗi al này. mô
hình cũng đã đưӧc nghiên cӭu trong khuôn
khә theo đӏnh hưӟng đӕi tưӧng cơ sӣ dӳ liӋu
trong Muth và cӝng sӵ. (1993) và Resende et
al. (1994).
Trong nhiӅu ӭng dөng, ngӳ nghĩa cӫa các
giao dӏch có thӇ không đưӧc biӃt đӃn và do
đó, nó là di bái đӇ cung cҩp cho phi hành
nghiêm ngһt. Trong trưӡng hӧp thӡi gian
thӵc, có các lӟp hӑc khác cӫa các hoҥt đӝng
mà không thӇ đưӧc bӗi thưӡng. Đây là nhӳng
hoҥt đӝng mà có mӝt bên ngoài e không thӇ
đҧo ngưӧc ¼ vv, chҷng hҥn như bàn giao sӕ
tiӅn rҩt lӟn cӫa tiӅn tҥi máy rút tiӅn tӵ đӝng.
hoҥt đӝng như vұy đã đưӧc hoãn lҥi cho đӃn
khi cҩp trên cam kӃt, trong đó hҥn chӃ sҹn có
(nghĩa là, tăng thӡi gian đáp ӭng).
µ µ
  
 
 
  

  
The intentions-list and undo-logging
recovery gorithms given in Fekete et al.
(1993) handle ecovery from transaction
aborts in the nested ransaction environment
by exploiting the ommutative properties of

Danh sách nhӳng ý đӏnh và quay lҥi khai thác
gӛ các thuұt toán phөc hӗi đưӧc đưa ra trong
et al Fekete. (1993) xӱ lý thu hӗi tӯ sӁ ngӯng
giao dӏch trong môi trưӡng giao dӏch lӗng
nhau bҵng cách khai thác các tính chҩt giao
the operations. The intentions-list algorithm
works by maintaining a list of operations for
each ansaction. When a transaction commits,
its list is appended to its parent; when it
aborts, the intentions-list is discarded. When
the top level transaction commits, its
intentions-list is transferred to the log. This
scheme provides recovery from transaction
aborts only and does not handle ystem
crashes. To increase concurrency during
undo logging recovery, scheme allows some
non-strict executions. It allows a ransaction
to share the uncommitted updates made by
other transactions by exploiting
commutativity of operations. On execution of
an operation, the data object records change
their states and the new state is transferred to
the log. When a transaction aborts, in
contrast to intentions-list lgorithm, all
operations executed by its descendants on the
object are undone from its current state and
are also subsequently removed from the log.
This lgorithm does not take care of recovery
from system crashes.
In both intentions-list and undo-logging algorithms,
an incomplete transaction is allowed to make
uncommitted updates available to those
transactions that perform a commutative
operation. However, this is restricted to
hoán cӫa các hoҥt đӝng. Các danh sách thuұt
toán có ý đӏnh hoҥt đӝng bҵng cách duy trì
mӝt danh sách các hoҥt đӝng cho mӛi giao
dӏch. Khi giao dӏch mӝt cam kӃt, danh sách
cӫa nó đưӧc nӕi vӟi mҽ cӫa nó, khi nó sӁ
ngӯng, nhӳng ý đӏnh danh sách bӏ loҥi. Khi
các giao dӏch cam kӃt ӣ cҩp cao nhҩt, danh
sách cӫa nó-nhӳng ý đӏnh đưӧc chuyӇn giao
cho đăng nhұp. Chương trình này cung cҩp sӁ
ngӯng giao dӏch phөc hӗi tӯ chӍ và không xӱ
lý sӵ cӕ hӋ thӕng. ĐӇ tăng đӗng thӡi trong
quá trình phөc hӗi hoàn tác đăng nhұp,
chương trình cho phép mӝt sӕ vө hành quyӃt
không nghiêm ngһt. Nó cho phép mӝt giao
dӏch đӇ chia sҿ các bҧn cұp nhұt không cam
kӃt đưӧc thӵc hiӋn bӣi các giao dӏch khác
bҵng cách khai thác commutativity hoҥt
đӝng. Trên thӵc hiӋn mӝt hoҥt đӝng, các đӕi
tưӧng dӳ liӋu hӗ sơ thay đәi trҥng thái cӫa hӑ
và nhà nưӟc mӟi đưӧc chuyӇn giao cho đăng
nhұp. Khi hӫy bӓ giao dӏch, trái ngưӧc vӟi ý
đӏnh, danh sách thuұt toán, tҩt cҧ các hoҥt
đӝng thӵc hiӋn bӣi các con cháu cӫa mình
vào đӕi tưӧng đưӧc hoàn tác tӯ trҥng thái
hiӋn tҥi cӫa mình và cũng sau đó lҩy ra tӯ
nhұt ký. Thuұt toán này không chăm sóc
phөc hӗi tӯ hӋ thӕng treo.
Trong cҧ hai danh sách nhӳng ý đӏnh và quay
lҥi khai thác gӛ các thuұt toán, giao dӏch chưa
hoàn chӍnh đưӧc phép cұp nhұt không cam
kӃt có sҹn cho nhӳng giao dӏch thӵc hiӋn mӝt
hoҥt đӝng giao hoán. Tuy nhiên, đây là hҥn
transactions at the same level of abstraction.
This limits availability. In both algorithms,
all the work done by descendent transactions
are discarded in case of aborts at higher
levels. This may not be possible or desirable
in many real time applications. In
undologging algorithm, when a transaction
aborts, in contrast to intentions-list algorithm,
all operations executed by its descendants on
the object are undone from its current state
and are subsequently removed from the log.
In both intentions-list and undo-logging
algorithms, an incomplete transaction is
allowed to make uncommitted updates
visible to those transactions that perform a
commutative operation. This is restricted to
the transactions at the same level of
abstraction.
The above two recovery models consider semantics of
operations at leaf level only. System R (Gray et al.,
1981) exploits layer speci®c semantics but
restricted to two level of transaction nesting.
In System R, to perform recovery, updates
are undone by performing inverse tuple-level
operations. For this purpose, System R
records tuple updates on a log. To recover
from a system crash, before applying any
tuple level log record, the database must ®rst
be restored to some tuple-level consistent
state. In other words, a low-level
recovermechanism is necessary to make tuple
chӃ giao dӏch tҥi cùng mӝt mӭc đӝ trӯu
tưӧng. ĐiӅu này có giӟi hҥn. Trong cҧ hai
thuұt toán, tҩt cҧ các công viӋc thӵc hiӋn các
giao dӏch hұu duӋ đưӧc bӓ trong trưӡng hӧp
hӫy bӓ ӣ cҩp cao hơn. ĐiӅu này có thӇ không
đưӧc có thӇ có hoһc mong muӕn trong thӡi
gian ӭng dөng thӵc tӃ rҩt nhiӅu. Trong thuұt
toán undologging, khi mӝt sӁ ngӯng giao
dӏch, trái ngưӧc vӟi ý đӏnh, danh sách các
thuұt toán, tҩt cҧ các hoҥt đӝng thӵc hiӋn bӣi
các con cháu cӫa mình vào đӕi tưӧng đưӧc
hoàn tác tӯ trҥng thái hiӋn tҥi cӫa mình và
sau đó lҩy ra tӯ nhұt ký. Trong cҧ hai danh
sách nhӳng ý đӏnh và quay lҥi khai thác gӛ
các thuұt toán, giao dӏch chưa hoàn chӍnh
đưӧc phép cұp nhұt không cam hiӇn thӏ cho
nhӳng giao dӏch thӵc hiӋn mӝt hoҥt đӝng
giao hoán. Đây là giӟi hҥn cho các giao dӏch
tҥi cùng mӝt mӭc đӝ trӯu tưӧng.
Các mô hình trên thu hӗi hai xem xét ngӳ
nghĩa cӫa các hoҥt đӝng ӣ mӭc lá chӍ. HӋ
thӕng R (Gray et al., 1981) khai thác lӟp ngӳ
nghĩa speci ® c nhưng hҥn chӃ đӃn hai mӭc
đӝ giao dӏch làm tә. Trong hӋ thӕng R, đӇ
thӵc hiӋn phөc hӗi, cұp nhұt đưӧc hoàn tác
bҵng cách thӵc hiӋn ngưӧc tuple cҩp hoҥt
đӝng. Vӟi mөc đích này, hӋ thӕng R cұp nhұt
hӗ sơ vӅ đăng nhұp mӝt tuple. ĐӇ phөc hӗi tӯ
sӵ cӕ hӋ thӕng trưӟc khi áp dөng bҩt cӭ hӗ sơ
cҩp đăng nhұp tuple, cơ sӣ dӳ liӋu rst phҧi ®
đưӧc khôi phөc lҥi mӝt sӕ mӭc đӝ phù hӧp
nhà tuple. Nói cách khác, mӝt cҩp thҩp phөc
actions appear atomic.
In Moss (1987), a crash recovery technique similar to
shadow page has been suggested in nested transaction
environment based on undo/redo log
methods. In terms of logging, both undo/redo
logs are used. Mohan et al. (1992, 1989) has
also discussed ``write ahead logging'' based
crash recovery algorithm using conventional
nested transaction model. This undo/redo
type of recovery model exploits semantics of
nested transactions. The actions of a
transaction undone during previous abort
have not been undone again in case of one
more failure. This is an advantage over
Weikum's multilevel recovery algorithm by
which requires undo actions to be undone
again in case of one more failure.
1.2. Our contributions
In this paper, we introduce an open and safe nested
transaction model in the environment of
normal read and write operations to remove
the de®ciencies stated above and to further
improve availability and provide ecient crash
recovery. Our model supports interand
intratransaction concurrency. We assume that
semantics of transactions at various levels of
nesting are not known. There are two basic
motivations behind our model. First, it is
hӗi cơ chӃ là cҫn thiӃt đӇ làm cho hành đӝng
tuple xuҩt hiӋn nguyên tӱ.
Trong Moss (1987), mӝt khôi phөc treo bóng
kӻ thuұt tương tӵ như trang đã đưӧc đӅ xuҩt
trong môi trưӡng giao dӏch lӗng nhau dӵa
trên undo / redo phương pháp đăng nhұp.
Trong điӅu kiӋn cӫa khai thác gӛ, cҧ hai hoàn
tác / làm lҥi đưӧc sӱ dөng các bҧn ghi.
Mohan và các cӝng sӵ. (1992, 1989) cũng đã
thҧo luұn `` viӃt đăng nhұp trưӟc''phөc hӗi
dӵa trên thuұt toán tai nҥn bҵng cách sӱ dөng
mô hình lӗng nhau giao dӏch thông thưӡng.
ĐiӅu này undo / redo loҥi phөc hӗi mô hình
khai thác ngӳ nghĩa cӫa các giao dӏch lӗng
nhau. Nhӳng hành đӝng cӫa mӝt giao dӏch
mӣ trong khi hӫy bӓ trưӟc đó đã không đưӧc
hoàn tác mӝt lҫn nӳa trong trưӡng hӧp có
thêm mӝt thҩt bҥi. Đây là mӝt lӧi thӃ hơn
nhiӅu mӭc phөc hӗi cӫa Weikum thuұt toán
mà yêu cҫu hoàn tác hành đӝng đưӧc hoàn lҥi
trong trưӡng hӧp có thêm mӝt thҩt bҥi.
1.2. đóng góp cӫa chúng tôi
Trong bài báo này, chúng tôi giӟi thiӋu mӝt
mô hình an toàn giao dӏch lӗng nhau và mӣ
trong môi trưӡng bình thưӡng đӑc và ghi các
hoҥt đӝng đӇ loҥi bӓ các de ® ciencies nêu
trên và nâng cao hơn nӳa khҧ dөng và cung
cҩp cient khôi phөc treo điӋn tӱ. mô hình cӫa
chúng tôi hӛ trӧ liên và giao dӏch trong nӝi
bӝ đӗng thӡi. Chúng tôi giҧ đӏnh rҵng ngӳ
nghĩa cӫa các giao dӏch ӣ mӭc đӝ khác nhau
làm tә không biӃt. Có hai đӝng lӵc cơ bҧn
desirable that long-lived transactions should
be able to release their locks before top-level
transactions commit. Second, it may not be
desirable or possible to undo or compensate
the e¼ects of one or more of the important
committed descendants after the failure of a
higher level transaction due to abort or a
system crash. We introduce the concept of a
`recovery point subtransaction'' of a top-level
transaction in a nested transaction tree. It is
essentially a ubtransaction after the commit
of which its ancestors are not allowed to
rollback. In other words, once the recovery
point subtransaction of a top-level transaction
has ommitted, all its superior transactions
are forced to commit. In case it aborts, its
ancestors can choose an alternate path to
complete their execution. Our nested
transaction model uses a prewrite operation
before an actual write operation to increase
the concurrency. The nested transaction tree
of our model consists of database operations,
system recovery operations (such as analysis
and redo operations) and bu¼er management
operations speci®ed as nested ransactions.
The read, prewrite and writes operations
are modeled at leaf levels in the transaction hierarchy. và làm lҥi hoҥt đӝng) và bu ¼ er speci hoҥt
The recovery operations are speci®ed in terms of
nested transactions to achieve higher concurrency
during system restart. Our locking algorithm controls
the execution of both the normal operations as well as
recovery operations. We also discuss the data giao dӏch. Các hoҥt đӝng phөc hӗi đưӧc speci
tructures required for the implementation of ® ed vӅ giao dӏch lӗng nhau đӇ đҥt đưӧc
cӫa mô hình cӫa chúng tôi. Trưӟc tiên, đó là
mong muӕn rҵng giao dӏch dài sӕng có thӇ
phát hành ә khóa cӫa mình trưӟc khi giao
dӏch cҩp cao cam kӃt. Thӭ hai, nó có thӇ
không đưӧc mong muӕn hoһc có thӇ lùi lҥi
hoһc bӗi thưӡng cho ECTS ¼ e cӫa mӝt hoһc
nhiӅu con cháu cam kӃt quan trӑng sau khi sӵ
thҩt bҥi cӫa mӝt giao dӏch cҩp cao hơn do
hӫy bӓ hoһc sөp đә hӋ thӕng. Chúng tôi giӟi
thiӋu các khái niӋm vӅ mӝt''phөc hӗi
`subtransaction điӇm cӫa mӝt giao dӏch cҩp
cao trong mӝt cây giao dӏch lӗng nhau. Đó là
bҧn chҩt là mӝt ubtransaction sau khi cam
kӃt, trong đó tә tiên cӫa nó là không đưӧc
phép rollback. Nói cách khác, mӝt khi các
điӇm khôi phөc subtransaction cӫa mӝt giao
dӏch cҩp cao đã bӓ qua, tҩt cҧ các giao dӏch
cҩp trên buӝc phҧi cam kӃt. Trong trưӡng
hӧp hӫy bӓ, tә tiên cӫa nó có thӇ chӑn mӝt
con đưӡng thay thӃ đӇ hoàn thành thӵc hiӋn.
mô hình giao dӏch lӗng nhau cӫa chúng tôi sӱ
dөng mӝt prewrite hoҥt đӝng trưӟc mӝt thӵc
tӃ hoҥt đӝng viӃt đӇ tăng tương tranh. Cây
giao dӏch lӗng nhau cӫa mô hình cӫa chúng
tôi bao gӗm các hoҥt đӝng cơ sӣ dӳ liӋu, các
hoҥt đӝng phөc hӗi hӋ thӕng (như phân tích
đӝng quҧn lý ® ed như ransactions lӗng
nhau. ViӋc đӑc, prewrite và ghi các hoҥt
đӝng đưӧc mô hình ӣ mӭc lá trong phân cҩp
the recovery algorithm. We have discussed a
snapshot of the concurrency and recovery
algorithm with the help of an example. A
brief overview of our crash recovery
algorithm has appeared in Madria et al.
(1997c). The correctness of the concurrency
control algorithm using I/O automation
model (FLMW) has reported in Madria et al.
(1997b).
đӗng thӡi cao hơn khi hӋ thӕng khӣi đӝng lҥi.
Thuұt toán khóa cӫa chúng tôi kiӇm soát viӋc
thӵc hiӋn cӫa cҧ hai hoҥt đӝng bình thưӡng
cũng như các hoҥt đӝng phөc hӗi. Chúng tôi
cũng thҧo luұn vӅ các dӳ liӋu cҫn thiӃt cho
tructures viӋc thӵc hiӋn các thuұt toán khôi
phөc. Chúng tôi đã thҧo luұn vӅ mӝt bҧn
chөp cӫa thuұt toán tương tranh và phөc hӗi
vӟi sӵ trӧ giúp cӫa mӝt ví dө. Mӝt tәng quan
vӅ các thuұt toán khôi phөc treo cӫa chúng
tôi đã xuҩt hiӋn trong Madria et al. (1997c).
Tính đúng đҳn cӫa các thuұt toán điӅu khiӇn
tương tranh sӱ dөng I / O tӵ đӝng hóa mô
hình (FLMW) đã báo cáo trong Madria et al.
(1997b).