← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/archive/concurrency_test.c

  • Committer: Monty Taylor
  • Date: 2008-07-15 21:40:58 UTC
  • mfrom: (77.1.113 codestyle32)
  • mto: This revision was merged to the branch mainline in revision 176.
  • Revision ID: mordred@camelot-20080715214058-rm3phulldos9xehv
Merged from codestyle.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/archive/concurrency_test.c
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2009 Sun Microsystems, Inc.
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; version 2 of the License.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
 
 */
19
 
 
20
1
/*
21
2
  Just a test application for threads.
22
3
  */
23
 
 
24
 
#include <config.h>
25
 
 
26
4
#include "azio.h"
 
5
#include <drizzle.h>
 
6
#include <my_getopt.h>
 
7
#include <drizzle_version.h>
27
8
#include <stdio.h>
28
9
#include <stdlib.h>
29
10
#include <sys/types.h>
33
14
#include <fcntl.h>
34
15
#include <sys/time.h>
35
16
#include <pthread.h>
36
 
#include <string.h>                             /* Pull in memset() */
 
17
#include <strings.h>
37
18
#ifndef __WIN__
38
19
#include <sys/wait.h>
39
20
#endif
40
 
#include <memory>
41
21
 
42
22
#ifdef __WIN__
43
23
#define srandom  srand
45
25
#define snprintf _snprintf
46
26
#endif
47
27
 
48
 
#include <boost/scoped_ptr.hpp>
49
 
 
50
28
#include "azio.h"
51
29
 
52
 
#define DEFAULT_CONCURRENCY     10
53
30
#define DEFAULT_INITIAL_LOAD 10000
54
31
#define DEFAULT_EXECUTE_SECONDS 120
 
32
#define DEFAULT_CONCURRENCY 8
55
33
#define TEST_FILENAME "concurrency_test.az"
56
34
 
57
35
#define HUGE_STRING_LENGTH 8192
63
41
unsigned int master_wakeup;
64
42
pthread_mutex_t sleeper_mutex;
65
43
pthread_cond_t sleep_threshhold;
66
 
static bool timer_alarm= false;
 
44
static my_bool timer_alarm= false;
67
45
pthread_mutex_t timer_alarm_mutex;
68
46
pthread_cond_t timer_alarm_threshold;
69
47
 
70
48
pthread_mutex_t row_lock;
71
49
 
72
50
/* Prototypes */
73
 
extern "C" {
74
 
  void *run_concurrent_task(void *p);
75
 
  void *timer_thread(void *p);
76
 
}
 
51
void *run_task(void *p);
 
52
void *timer_thread(void *p);
77
53
void scheduler(az_method use_aio);
78
 
void create_data_file(azio_stream *write_handler, uint64_t rows);
 
54
void create_data_file(azio_stream *write_handler, unsigned long long rows);
79
55
unsigned int write_row(azio_stream *s);
80
56
 
81
57
typedef struct thread_context_st thread_context_st;
82
58
struct thread_context_st {
83
59
  unsigned int how_often_to_write;
84
 
  uint64_t counter;
 
60
  unsigned long long counter;
85
61
  az_method use_aio;
86
62
  azio_stream *writer;
87
63
};
104
80
int main(int argc, char *argv[])
105
81
{
106
82
 
107
 
  unsigned int method;
108
 
  drizzled::internal::my_init();
 
83
  az_method method;
 
84
  my_init();
109
85
 
110
86
  MY_INIT(argv[0]);
111
87
 
112
88
  if (argc > 1)
113
89
    exit(1);
114
90
 
 
91
  if (!(mysql_thread_safe()))
 
92
      fprintf(stderr, "This application was compiled incorrectly. Please recompile with thread support.\n");
 
93
 
115
94
  srandom(time(NULL));
116
95
 
117
96
  pthread_mutex_init(&counter_mutex, NULL);
118
97
  pthread_cond_init(&count_threshhold, NULL);
119
98
  pthread_mutex_init(&sleeper_mutex, NULL);
120
99
  pthread_cond_init(&sleep_threshhold, NULL);
121
 
  pthread_mutex_init(&timer_alarm_mutex, NULL);
122
 
  pthread_cond_init(&timer_alarm_threshold, NULL);
123
 
  pthread_mutex_init(&row_lock, NULL);
 
100
  VOID(pthread_mutex_init(&timer_alarm_mutex, NULL));
 
101
  VOID(pthread_cond_init(&timer_alarm_threshold, NULL));
 
102
  VOID(pthread_mutex_init(&row_lock, NULL));
124
103
 
125
104
  for (method= AZ_METHOD_BLOCK; method < AZ_METHOD_MAX; method++)
126
 
    scheduler((az_method)method);
 
105
    scheduler(method);
127
106
 
128
107
  (void)pthread_mutex_destroy(&counter_mutex);
129
108
  (void)pthread_cond_destroy(&count_threshhold);
130
109
  (void)pthread_mutex_destroy(&sleeper_mutex);
131
110
  (void)pthread_cond_destroy(&sleep_threshhold);
132
 
  pthread_mutex_destroy(&timer_alarm_mutex);
133
 
  pthread_cond_destroy(&timer_alarm_threshold);
134
 
  pthread_mutex_destroy(&row_lock);
 
111
  VOID(pthread_mutex_destroy(&timer_alarm_mutex));
 
112
  VOID(pthread_cond_destroy(&timer_alarm_threshold));
 
113
  VOID(pthread_mutex_destroy(&row_lock));
135
114
 
136
115
  return 0;
137
116
}
139
118
void scheduler(az_method use_aio)
140
119
{
141
120
  unsigned int x;
142
 
  uint64_t total;
143
 
  boost::scoped_ptr<azio_stream> writer_handle_ap(new azio_stream);
144
 
  azio_stream &writer_handle= *writer_handle_ap.get();
 
121
  unsigned long long total;
 
122
  azio_stream writer_handle;
145
123
  thread_context_st *context;
146
124
  pthread_t mainthread;            /* Thread descriptor */
147
125
  pthread_attr_t attr;          /* Thread attributes */
160
138
  pthread_mutex_unlock(&sleeper_mutex);
161
139
 
162
140
  context= (thread_context_st *)malloc(sizeof(thread_context_st) * DEFAULT_CONCURRENCY);
163
 
  memset(context, 0, sizeof(thread_context_st) * DEFAULT_CONCURRENCY);
 
141
  bzero(context, sizeof(thread_context_st) * DEFAULT_CONCURRENCY);
164
142
 
165
143
  if (!context)
166
144
  {
177
155
    context[x].use_aio= use_aio;
178
156
 
179
157
    /* now you create the thread */
180
 
    if (pthread_create(&mainthread, &attr, run_concurrent_task,
 
158
    if (pthread_create(&mainthread, &attr, run_task,
181
159
                       (void *)context) != 0)
182
160
    {
183
161
      fprintf(stderr,"Could not create thread\n");
193
171
    timer_alarm= true;
194
172
    pthread_mutex_unlock(&timer_alarm_mutex);
195
173
 
196
 
    if (pthread_create(&mainthread, &attr, timer_thread,
 
174
    if (pthread_create(&mainthread, &attr, timer_thread, 
197
175
                       (void *)&opt_timer_length) != 0)
198
176
    {
199
 
      fprintf(stderr,"%s: Could not create timer thread\n", drizzled::internal::my_progname);
 
177
      fprintf(stderr,"%s: Could not create timer thread\n", my_progname);
200
178
      exit(1);
201
179
    }
202
180
  }
217
195
  {
218
196
    struct timespec abstime;
219
197
 
220
 
    memset(&abstime, 0, sizeof(struct timespec));
 
198
    bzero(&abstime, sizeof(struct timespec));
221
199
    abstime.tv_sec= 1;
222
200
 
223
201
    pthread_cond_timedwait(&count_threshhold, &counter_mutex, &abstime);
230
208
  free(context);
231
209
  azclose(&writer_handle);
232
210
 
233
 
  printf("Read %"PRIu64" rows\n", total);
 
211
  printf("Read %llu rows\n", total);
234
212
}
235
213
 
236
214
void *timer_thread(void *p)
238
216
  time_t *timer_length= (time_t *)p;
239
217
  struct timespec abstime;
240
218
 
241
 
  /*
242
 
    We lock around the initial call in case were we in a loop. This
 
219
  if (mysql_thread_init())
 
220
  {
 
221
    fprintf(stderr,"%s: mysql_thread_init() failed.\n",
 
222
            my_progname);
 
223
    exit(1);
 
224
  }
 
225
 
 
226
  /* 
 
227
    We lock around the initial call in case were we in a loop. This 
243
228
    also keeps the value properly syncronized across call threads.
244
229
  */
245
230
  pthread_mutex_lock(&sleeper_mutex);
259
244
  timer_alarm= false;
260
245
  pthread_mutex_unlock(&timer_alarm_mutex);
261
246
 
 
247
  mysql_thread_end();
 
248
 
262
249
  return 0;
263
250
}
264
251
 
265
 
void *run_concurrent_task(void *p)
 
252
void *run_task(void *p)
266
253
{
267
254
  thread_context_st *context= (thread_context_st *)p;
268
 
  uint64_t count;
 
255
  unsigned long long count;
269
256
  int ret;
270
257
  int error;
271
 
  boost::scoped_ptr<azio_stream> reader_handle_ap(new azio_stream);
272
 
  azio_stream &reader_handle= *reader_handle_ap.get();
273
 
 
274
 
  if (!(ret= azopen(&reader_handle, TEST_FILENAME, O_RDONLY,
 
258
  azio_stream reader_handle;
 
259
 
 
260
  if (mysql_thread_init())
 
261
  {
 
262
    fprintf(stderr,"%s: mysql_thread_init() failed.\n", my_progname);
 
263
    exit(1);
 
264
  }
 
265
 
 
266
  if (!(ret= azopen(&reader_handle, TEST_FILENAME, O_RDONLY|O_BINARY,
275
267
                    context->use_aio)))
276
268
  {
277
269
    printf("Could not open test file\n");
282
274
  while (master_wakeup)
283
275
  {
284
276
    pthread_cond_wait(&sleep_threshhold, &sleeper_mutex);
285
 
  }
 
277
  } 
286
278
  pthread_mutex_unlock(&sleeper_mutex);
287
279
 
288
280
  /* Do Stuff */
309
301
  pthread_mutex_unlock(&counter_mutex);
310
302
  azclose(&reader_handle);
311
303
 
 
304
  mysql_thread_end();
 
305
 
312
306
  return NULL;
313
307
}
314
308
 
315
 
void create_data_file(azio_stream *write_handler, uint64_t rows)
 
309
void create_data_file(azio_stream *write_handler, unsigned long long rows)
316
310
{
317
311
  int ret;
318
 
  uint64_t x;
 
312
  unsigned long long x;
319
313
 
320
 
  if (!(ret= azopen(write_handler, TEST_FILENAME, O_CREAT|O_RDWR|O_TRUNC,
 
314
  if (!(ret= azopen(write_handler, TEST_FILENAME, O_CREAT|O_RDWR|O_TRUNC|O_BINARY,
321
315
                    AZ_METHOD_BLOCK)))
322
316
  {
323
317
    printf("Could not create test file\n");
340
334
  /* Avoid zero length strings */
341
335
  length++;
342
336
 
343
 
  get_random_string(buffer, length);
 
337
  get_random_string(buffer, length); 
344
338
  pthread_mutex_lock(&row_lock);
345
339
  azwrite_row(s, buffer, length);
346
340
  pthread_mutex_unlock(&row_lock);