← Back to branch summary

~bkerensa/ubuntu/raring/valgrind/merge-from-deb

« back to all changes in this revision

Viewing changes to exp-drd/tests/pth_detached.c

  • Committer: Bazaar Package Importer
  • Author(s): Andrés Roldán
  • Date: 2008-06-13 02:31:40 UTC
  • mto: (1.4.1 upstream) (2.2.1 squeeze)
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: james.westby@ubuntu.com-20080613023140-iwk33rz9rhvfkr96
Import upstream version 3.3.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
exp-drd/tests/pth_detached.c
 
1
/* Test whether detached threads are handled properly.
 
2
   Contributed by Bart Van Assche (bart.vanassche@gmail.com).
 
3
*/
 
4
 
 
5
#include <assert.h>
 
6
#include <pthread.h>
 
7
#include <stdio.h>
 
8
#include <stdlib.h>
 
9
#include <unistd.h>
 
10
#include "../drd_clientreq.h"
 
11
 
 
12
static int s_finished_count;
 
13
static pthread_mutex_t s_mutex;
 
14
 
 
15
static void set_thread_name(const char* const fmt, const int arg)
 
16
{
 
17
  int res;
 
18
  char name[32];
 
19
  snprintf(name, sizeof(name), fmt, arg);
 
20
  name[sizeof(name) - 1] = 0;
 
21
  VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__SET_THREAD_NAME,
 
22
                             name, 0, 0, 0, 0);
 
23
}
 
24
 
 
25
void increment_finished_count()
 
26
{
 
27
  pthread_mutex_lock(&s_mutex);
 
28
  s_finished_count++;
 
29
  pthread_mutex_unlock(&s_mutex);
 
30
}
 
31
 
 
32
int get_finished_count()
 
33
{
 
34
  int result;
 
35
  pthread_mutex_lock(&s_mutex);
 
36
  result = s_finished_count;
 
37
  pthread_mutex_unlock(&s_mutex);
 
38
  return result;
 
39
}
 
40
 
 
41
static void* thread_func1(void* arg)
 
42
{
 
43
  set_thread_name("thread_func1[%d]", *(int*)arg);
 
44
  write(STDOUT_FILENO, ".", 1);
 
45
  increment_finished_count();
 
46
  return 0;
 
47
}
 
48
 
 
49
static void* thread_func2(void* arg)
 
50
{
 
51
  set_thread_name("thread_func2[%d]", *(int*)arg);
 
52
  pthread_detach(pthread_self());
 
53
  write(STDOUT_FILENO, ".", 1);
 
54
  increment_finished_count();
 
55
  return 0;
 
56
}
 
57
 
 
58
int main(int argc, char** argv)
 
59
{
 
60
  const int count1 = argc > 1 ? atoi(argv[1]) : 100;
 
61
  const int count2 = argc > 2 ? atoi(argv[2]) : 100;
 
62
  int thread_arg[count1 > count2 ? count1 : count2];
 
63
  int i;
 
64
  int detachstate;
 
65
  pthread_attr_t attr;
 
66
 
 
67
  set_thread_name("main", 0);
 
68
 
 
69
  for (i = 0; i < count1 || i < count2; i++)
 
70
    thread_arg[i] = i;
 
71
 
 
72
  pthread_mutex_init(&s_mutex, 0);
 
73
  
 
74
  pthread_attr_init(&attr);
 
75
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 
76
  assert(pthread_attr_getdetachstate(&attr, &detachstate) == 0);
 
77
  assert(detachstate == PTHREAD_CREATE_DETACHED);
 
78
  pthread_attr_setstacksize(&attr, 16384);
 
79
  // Create count1 detached threads by setting the "detached" property via 
 
80
  // thread attributes.
 
81
  for (i = 0; i < count1; i++)
 
82
  {
 
83
    pthread_t thread;
 
84
    pthread_create(&thread, &attr, thread_func1, &thread_arg[i]);
 
85
  }
 
86
  // Create count2 detached threads by letting the threads detach themselves.
 
87
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 
88
  assert(pthread_attr_getdetachstate(&attr, &detachstate) == 0);
 
89
  assert(detachstate == PTHREAD_CREATE_JOINABLE);
 
90
  for (i = 0; i < count2; i++)
 
91
  {
 
92
    pthread_t thread;
 
93
    pthread_create(&thread, &attr, thread_func2, &thread_arg[i]);
 
94
  }
 
95
  pthread_attr_destroy(&attr);
 
96
 
 
97
  // Wait until all detached threads have written their output to stdout.
 
98
  while (get_finished_count() < count1 + count2)
 
99
  {
 
100
    struct timespec delay = { 0, 1 * 1000 * 1000 };
 
101
    nanosleep(&delay, 0);
 
102
  }
 
103
 
 
104
  printf("\n");
 
105
 
 
106
  pthread_mutex_destroy(&s_mutex);
 
107
 
 
108
  return 0;
 
109
}