OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [gdb/] [testsuite/] [gdb.threads/] [schedlock.exp] - Blame information for rev 330

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn
# Copyright (C) 1996, 1997, 2002, 2003, 2007, 2008, 2009, 2010
2
# Free Software Foundation, Inc.
3
 
4
# This program is free software; you can redistribute it and/or modify
5
# it under the terms of the GNU General Public License as published by
6
# the Free Software Foundation; either version 3 of the License, or
7
# (at your option) any later version.
8
#
9
# This program is distributed in the hope that it will be useful,
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
# GNU General Public License for more details.
13
#
14
# You should have received a copy of the GNU General Public License
15
# along with this program.  If not, see .
16
 
17
# This file was written by Daniel Jacobowitz 
18
# (parts based on pthreads.exp by Fred Fish (fnf@cygnus.com).
19
#
20
# This test covers the various forms of "set scheduler-locking".
21
 
22
if $tracelevel then {
23
        strace $tracelevel
24
}
25
 
26
 
27
set testfile "schedlock"
28
set srcfile ${testfile}.c
29
set binfile ${objdir}/${subdir}/${testfile}
30
 
31
# The number of threads, including the main thread.
32
set NUM 2
33
 
34
if {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug "incdir=${objdir}"]] != "" } {
35
    return -1
36
}
37
 
38
# Now we can proceed with the real testing.
39
 
40
proc get_args { } {
41
    global list_count
42
    global gdb_prompt
43
    global NUM
44
 
45
    set pattern "(\[0-9\]+)"
46
    for {set i 1} {[expr $i < $NUM]} {incr i} {
47
        append pattern ", (\[0-9\]+)"
48
    }
49
 
50
    gdb_test_multiple "print args" "listed args ($list_count)" {
51
        -re "\\\$\[0-9\]+ = {$pattern}.*$gdb_prompt $" {
52
            set list_count [expr $list_count + 1]
53
            pass "listed args ($list_count)"
54
 
55
            set result ""
56
            for {set i 1} {[expr $i <= $NUM]} {incr i} {
57
                lappend result $expect_out($i,string)
58
            }
59
            return $result
60
        }
61
    }
62
}
63
 
64
proc stop_process { description } {
65
  global gdb_prompt
66
 
67
  # For this to work we must be sure to consume the "Continuing."
68
  # message first, or GDB's signal handler may not be in place.
69
  after 1000 {send_gdb "\003"}
70
  gdb_expect {
71
    -re "Program received signal SIGINT.*$gdb_prompt $"
72
      {
73
        pass $description
74
      }
75
    timeout
76
      {
77
        fail "$description (timeout)"
78
      }
79
  }
80
}
81
 
82
proc get_current_thread { description } {
83
    global gdb_prompt
84
 
85
    gdb_test_multiple "bt" "$description" {
86
        -re "thread_function \\(arg=0x(\[0-9\])\\).*$gdb_prompt $" {
87
            pass $description
88
            return $expect_out(1,string)
89
        }
90
    }
91
    return ""
92
}
93
 
94
proc my_continue { msg } {
95
    gdb_test_multiple "continue" "continuing ($msg)" {
96
        -re "Continuing" {
97
            pass "continue ($msg)"
98
        }
99
    }
100
 
101
    stop_process "stop all threads ($msg)"
102
 
103
    # Make sure we're in one of the non-main looping threads.
104
    gdb_breakpoint [concat [gdb_get_line_number "schedlock.exp: main loop"] " if arg != 0"]
105
    gdb_continue_to_breakpoint "return to loop ($msg)"
106
    delete_breakpoints
107
}
108
 
109
proc step_ten_loops { msg } {
110
    global gdb_prompt
111
 
112
    for {set i 0} {[expr $i < 10]} {set i [expr $i + 1]} {
113
        set other_step 0
114
        gdb_test_multiple "step" "step to increment ($msg $i)" {
115
            -re ".*myp\\) \\+\\+;\[\r\n\]+$gdb_prompt $" {
116
                pass "step to increment ($msg $i)"
117
            }
118
            -re "$gdb_prompt $" {
119
                if {$other_step == 0} {
120
                    set other_step 1
121
                    send_gdb "step\n"
122
                    exp_continue
123
                } else {
124
                    fail "step to increment ($msg $i)"
125
                    # FIXME cascade?
126
                }
127
            }
128
        }
129
    }
130
}
131
 
132
# Start with a fresh gdb.
133
 
134
gdb_exit
135
gdb_start
136
gdb_reinitialize_dir $srcdir/$subdir
137
 
138
# We'll need this when we send_gdb a ^C to GDB.  Need to do it before we
139
# run the program and gdb starts saving and restoring tty states.
140
# On Ultrix, we don't need it and it is really slow (because shell_escape
141
# doesn't use vfork).
142
if ![istarget "*-*-ultrix*"] then {
143
    gdb_test "shell stty intr '^C'" ".*"
144
}
145
 
146
gdb_load ${binfile}
147
 
148
gdb_test_no_output "set print sevenbit-strings"
149
gdb_test_no_output "set width 0"
150
 
151
runto_main
152
 
153
# See if scheduler locking is available on this target.
154
global gdb_prompt
155
gdb_test_multiple "set scheduler-locking off" "scheduler locking set to none" {
156
    -re "Target .* cannot support this command" {
157
        unsupported "target does not support scheduler locking"
158
        return
159
    }
160
    -re "$gdb_prompt $" {
161
        pass "scheduler locking set to none"
162
    }
163
    timeout {
164
        unsupported "target does not support scheduler locking (timeout)"
165
        return
166
    }
167
}
168
 
169
gdb_breakpoint [gdb_get_line_number "schedlock.exp: last thread start"]
170
gdb_continue_to_breakpoint "all threads started"
171
 
172
global list_count
173
set list_count 0
174
 
175
set start_args [get_args]
176
 
177
# First make sure that all threads are alive.
178
my_continue "initial"
179
 
180
set cont_args [get_args]
181
 
182
set bad 0
183
for {set i 0} {[expr $i < $NUM]} {set i [expr $i + 1]} {
184
  if {[lindex $start_args $i] == [lindex $cont_args $i]} {
185
    incr bad
186
  }
187
}
188
if { $bad == 0 } {
189
  pass "all threads alive"
190
} else {
191
  fail "all threads alive ($bad/$NUM did not run)"
192
}
193
 
194
# We can't change threads, unfortunately, in current GDB.  Use
195
# whichever we stopped in.
196
set curthread [get_current_thread "find current thread (1)"]
197
 
198
 
199
 
200
 
201
# Test stepping without scheduler locking.
202
gdb_test_no_output "set scheduler-locking off"
203
 
204
step_ten_loops "unlocked"
205
 
206
# Make sure we're still in the same thread.
207
set newthread [get_current_thread "find current thread (2)"]
208
if {$curthread == $newthread} {
209
    pass "step without lock does not change thread"
210
} else {
211
    fail "step without lock does not change thread (switched to thread $newthread)"
212
}
213
 
214
set start_args $cont_args
215
set cont_args [get_args]
216
 
217
set num_other_threads 0
218
for {set i 0} {[expr $i < $NUM]} {set i [expr $i + 1]} {
219
  if {[lindex $start_args $i] == [lindex $cont_args $i]} {
220
    if {$i == $curthread} {
221
      fail "current thread stepped (didn't run)"
222
    }
223
  } else {
224
    if {$i == $curthread} {
225
        if {[lindex $start_args $i] == [expr [lindex $cont_args $i] - 10]} {
226
            pass "current thread stepped"
227
        } else {
228
            fail "current thread stepped (wrong amount)"
229
        }
230
    } else {
231
      set num_other_threads [expr $num_other_threads + 1]
232
    }
233
  }
234
}
235
if {$num_other_threads > 0} {
236
  pass "other threads ran - unlocked"
237
} else {
238
  fail "other threads ran - unlocked"
239
}
240
 
241
# Test continue with scheduler locking
242
gdb_test "set scheduler-locking on" ""
243
 
244
my_continue "with lock"
245
 
246
# Make sure we're still in the same thread.
247
set newthread [get_current_thread "find current thread (3)"]
248
if {$curthread == $newthread} {
249
    pass "continue with lock does not change thread"
250
} else {
251
    fail "continue with lock does not change thread (switched to thread $newthread)"
252
}
253
 
254
set start_args $cont_args
255
set cont_args [get_args]
256
 
257
set num_other_threads 0
258
for {set i 0} {[expr $i < $NUM]} {set i [expr $i + 1]} {
259
  if {[lindex $start_args $i] == [lindex $cont_args $i]} {
260
    if {$i == $curthread} {
261
      fail "current thread ran (didn't run)"
262
    }
263
  } else {
264
    if {$i == $curthread} {
265
      pass "current thread ran"
266
    } else {
267
      incr num_other_threads
268
    }
269
  }
270
}
271
if {$num_other_threads > 0} {
272
  fail "other threads didn't run - locked"
273
} else {
274
  pass "other threads didn't run - locked"
275
}
276
 
277
# Test stepping with scheduler locking
278
step_ten_loops "locked"
279
 
280
# Make sure we're still in the same thread.
281
set newthread [get_current_thread "find current thread (2)"]
282
if {$curthread == $newthread} {
283
    pass "step with lock does not change thread"
284
} else {
285
    fail "step with lock does not change thread (switched to thread $newthread)"
286
}
287
 
288
set start_args $cont_args
289
set cont_args [get_args]
290
 
291
set num_other_threads 0
292
for {set i 0} {[expr $i < $NUM]} {set i [expr $i + 1]} {
293
  if {[lindex $start_args $i] == [lindex $cont_args $i]} {
294
    if {$i == $curthread} {
295
      fail "current thread stepped locked (didn't run)"
296
    }
297
  } else {
298
    if {$i == $curthread} {
299
        if {[lindex $start_args $i] == [expr [lindex $cont_args $i] - 10]} {
300
            pass "current thread stepped locked"
301
        } else {
302
            fail "current thread stepped locked (wrong amount)"
303
        }
304
    } else {
305
      incr num_other_threads
306
    }
307
  }
308
}
309
if {$num_other_threads > 0} {
310
  fail "other threads didn't run - step locked"
311
} else {
312
  pass "other threads didn't run - step locked"
313
}
314
 
315
return 0

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.