Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commit9be4ce4

Browse files
committed
Make deadlock-parallel isolation test more robust.
This test failed fairly reproducibly on some CLOBBER_CACHE_ALWAYSbuildfarm animals. The cause seems to be that if a parallel workeris slow enough to reach its lock wait, it may not be released bythe first deadlock check run, and then later deadlock checks mightdecide to unblock the d2 session instead of the d1 session, leavingus in an undetected deadlock state (since the isolationtester clientis waiting for d1 to complete first).Fix by introducing an additional lock wait at the end of the d2a1step, ensuring that the deadlock checker will recognize that d1has to be unblocked before d2a1 completes.Also reduce max_parallel_workers_per_gather to 3 in this test. With thedefault max_worker_processes value, we were only getting one parallelworker for the d2a1 step, which is not the case I hoped to test. Weshould get 3 for d1a2 and 2 for d2a1, as the code stands; and maybe 3for d2a1 if somebody figures out why the last parallel worker slot isn'tfree already.Discussion:https://postgr.es/m/22195.1566077308@sss.pgh.pa.us
1 parentd78d452 commit9be4ce4

File tree

2 files changed

+43
-12
lines changed

2 files changed

+43
-12
lines changed

‎src/test/isolation/expected/deadlock-parallel.out

Lines changed: 13 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,10 @@
11
Parsed test spec with 4 sessions
22

33
starting permutation: d1a1 d2a2 e1l e2l d1a2 d2a1 d1c e1c d2c e2c
4-
step d1a1: SELECT lock_share(1,x) FROM bigt LIMIT 1;
5-
lock_share
4+
step d1a1: SELECT lock_share(1,x), lock_excl(3,x) FROM bigt LIMIT 1;
5+
lock_sharelock_excl
66

7-
1
7+
11
88
step d2a2: select lock_share(2,x) FROM bigt LIMIT 1;
99
lock_share
1010

@@ -16,15 +16,19 @@ step d1a2: SET force_parallel_mode = on;
1616
SET parallel_tuple_cost = 0;
1717
SET min_parallel_table_scan_size = 0;
1818
SET parallel_leader_participation = off;
19-
SET max_parallel_workers_per_gather =4;
19+
SET max_parallel_workers_per_gather =3;
2020
SELECT sum(lock_share(2,x)) FROM bigt; <waiting ...>
2121
step d2a1: SET force_parallel_mode = on;
2222
SET parallel_setup_cost = 0;
2323
SET parallel_tuple_cost = 0;
2424
SET min_parallel_table_scan_size = 0;
2525
SET parallel_leader_participation = off;
26-
SET max_parallel_workers_per_gather = 4;
27-
SELECT sum(lock_share(1,x)) FROM bigt; <waiting ...>
26+
SET max_parallel_workers_per_gather = 3;
27+
SELECT sum(lock_share(1,x)) FROM bigt;
28+
SET force_parallel_mode = off;
29+
RESET parallel_setup_cost;
30+
RESET parallel_tuple_cost;
31+
SELECT lock_share(3,x) FROM bigt LIMIT 1; <waiting ...>
2832
step d1a2: <... completed>
2933
sum
3034

@@ -38,6 +42,9 @@ step d2a1: <... completed>
3842
sum
3943

4044
10000
45+
lock_share
46+
47+
1
4148
step e1c: COMMIT;
4249
step d2c: COMMIT;
4350
step e2l: <... completed>

‎src/test/isolation/specs/deadlock-parallel.spec

Lines changed: 30 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -15,6 +15,25 @@
1515
# The deadlock detector resolves the deadlock by reversing the d1-e2 edge,
1616
# unblocking d1.
1717

18+
# However ... it's not actually that well-defined whether the deadlock
19+
# detector will prefer to unblock d1 or d2. It depends on which backend
20+
# is first to run DeadLockCheck after the deadlock condition is created:
21+
# that backend will search outwards from its own wait condition, and will
22+
# first find a loop involving the *other* lock. We encourage that to be
23+
# one of the d2a1 parallel workers, which will therefore unblock d1a2
24+
# workers, by setting a shorter deadlock_timeout in session d2. But on
25+
# slow machines, one or more d1a2 workers may not yet have reached their
26+
# lock waits, so that they're not unblocked by the first DeadLockCheck.
27+
# The next DeadLockCheck may choose to unblock the d2a1 workers instead,
28+
# which would allow d2a1 to complete before d1a2, causing the test to
29+
# freeze up because isolationtester isn't expecting that completion order.
30+
# (In effect, we have an undetectable deadlock because d2 is waiting for
31+
# d1's completion, but on the client side.) To fix this, introduce an
32+
# additional lock (advisory lock 3), which is initially taken by d1 and
33+
# then d2a1 will wait for it after completing the main part of the test.
34+
# In this way, the deadlock detector can see that d1 must be completed
35+
# first, regardless of timing.
36+
1837
setup
1938
{
2039
createfunctionlock_share(int,int)returnsintlanguagesqlas
@@ -39,15 +58,15 @@ setup{ BEGIN isolation level repeatable read;
3958
SETforce_parallel_mode=off;
4059
SETdeadlock_timeout='10s';
4160
}
42-
#this lock will be taken in the leader, soit will persist:
43-
step"d1a1"{SELECTlock_share(1,x)FROMbigtLIMIT1; }
61+
#these locks will be taken in the leader, sothey will persist:
62+
step"d1a1"{SELECTlock_share(1,x),lock_excl(3,x)FROMbigtLIMIT1; }
4463
# this causes all the parallel workers to take locks:
4564
step"d1a2"{SETforce_parallel_mode=on;
4665
SETparallel_setup_cost=0;
4766
SETparallel_tuple_cost=0;
4867
SETmin_parallel_table_scan_size=0;
4968
SETparallel_leader_participation=off;
50-
SETmax_parallel_workers_per_gather=4;
69+
SETmax_parallel_workers_per_gather=3;
5170
SELECTsum(lock_share(2,x))FROMbigt; }
5271
step"d1c"{COMMIT; }
5372

@@ -58,14 +77,19 @@ setup{ BEGIN isolation level repeatable read;
5877
}
5978
# this lock will be taken in the leader, so it will persist:
6079
step"d2a2"{selectlock_share(2,x)FROMbigtLIMIT1; }
61-
# this causes all the parallel workers to take locks:
80+
# this causes all the parallel workers to take locks;
81+
# after which, make the leader take lock 3 to prevent client-driven deadlock
6282
step"d2a1"{SETforce_parallel_mode=on;
6383
SETparallel_setup_cost=0;
6484
SETparallel_tuple_cost=0;
6585
SETmin_parallel_table_scan_size=0;
6686
SETparallel_leader_participation=off;
67-
SETmax_parallel_workers_per_gather=4;
68-
SELECTsum(lock_share(1,x))FROMbigt; }
87+
SETmax_parallel_workers_per_gather=3;
88+
SELECTsum(lock_share(1,x))FROMbigt;
89+
SETforce_parallel_mode=off;
90+
RESETparallel_setup_cost;
91+
RESETparallel_tuple_cost;
92+
SELECTlock_share(3,x)FROMbigtLIMIT1; }
6993
step"d2c"{COMMIT; }
7094

7195
session"e1"

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp