← Back to branch summary

~mordred/gearmand/solaris-64-fixes

« back to all changes in this revision

Viewing changes to benchmark/blobslap_worker.c

  • Committer: Brian Aker
  • Date: 2009-01-20 00:07:16 UTC
  • mfrom: (19.1.69 fixes)
  • Revision ID: brian@tangent.org-20090120000716-guv1cplv7p0tsffr
Merge from Eric

Show diffs side-by-side

added added

removed removed

Lines of Context:
benchmark/blobslap_worker.c
 
1
/* Gearman server and library
 
2
 * Copyright (C) 2008 Brian Aker, Eric Day
 
3
 * All rights reserved.
 
4
 *
 
5
 * Use and distribution licensed under the BSD license.  See
 
6
 * the COPYING file in the parent directory for full text.
 
7
 */
 
8
 
 
9
/**
 
10
 * @file
 
11
 * @brief Blob slap worker utility
 
12
 */
 
13
 
 
14
#include "benchmark.h"
 
15
 
 
16
static void *worker_fn(gearman_job_st *job, void *cb_arg, size_t *result_size,
 
17
                       gearman_return_t *ret_ptr);
 
18
 
 
19
static void usage(char *name);
 
20
 
 
21
int main(int argc, char *argv[])
 
22
{
 
23
  gearman_benchmark_st benchmark;
 
24
  char c;
 
25
  char *host= NULL;
 
26
  in_port_t port= 0;
 
27
  char *function= NULL;
 
28
  uint32_t count= 0;
 
29
  gearman_return_t ret;
 
30
  gearman_worker_st worker;
 
31
 
 
32
  benchmark_init(&benchmark);
 
33
 
 
34
  if (gearman_worker_create(&worker) == NULL)
 
35
  {
 
36
    fprintf(stderr, "Memory allocation failure on worker creation\n");
 
37
    exit(1);
 
38
  }
 
39
 
 
40
  while ((c = getopt(argc, argv, "c:f:h:p:v")) != EOF)
 
41
  {
 
42
    switch(c)
 
43
    {
 
44
    case 'c':
 
45
      count= atoi(optarg);
 
46
      break;
 
47
 
 
48
    case 'f':
 
49
      function= optarg;
 
50
      ret= gearman_worker_add_function(&worker, function, 0, worker_fn,
 
51
                                       &benchmark);
 
52
      if (ret != GEARMAN_SUCCESS)
 
53
      {
 
54
        fprintf(stderr, "%s\n", gearman_worker_error(&worker));
 
55
        exit(1);
 
56
      }
 
57
      break;
 
58
 
 
59
    case 'h':
 
60
      host= optarg;
 
61
      ret= gearman_worker_add_server(&worker, host, port);
 
62
      if (ret != GEARMAN_SUCCESS)
 
63
      {
 
64
        fprintf(stderr, "%s\n", gearman_worker_error(&worker));
 
65
        exit(1);
 
66
      }
 
67
      break;
 
68
 
 
69
    case 'p':
 
70
      port= atoi(optarg);
 
71
      break;
 
72
 
 
73
    case 'v':
 
74
      benchmark.verbose++;
 
75
      break;
 
76
 
 
77
    default:
 
78
      usage(argv[0]);
 
79
      exit(1);
 
80
    }
 
81
  }
 
82
 
 
83
  if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
 
84
  {
 
85
    fprintf(stderr, "signal:%d\n", errno);
 
86
    exit(1);
 
87
  }
 
88
 
 
89
  if (host == NULL)
 
90
  {
 
91
    ret= gearman_worker_add_server(&worker, NULL, port);
 
92
    if (ret != GEARMAN_SUCCESS)
 
93
    {
 
94
      fprintf(stderr, "%s\n", gearman_worker_error(&worker));
 
95
      exit(1);
 
96
    }
 
97
  }
 
98
 
 
99
  if (function == NULL)
 
100
  {
 
101
    ret= gearman_worker_add_function(&worker,
 
102
                                     GEARMAN_BENCHMARK_DEFAULT_FUNCTION, 0,
 
103
                                     worker_fn, &benchmark);
 
104
    if (ret != GEARMAN_SUCCESS)
 
105
    {
 
106
      fprintf(stderr, "%s\n", gearman_worker_error(&worker));
 
107
      exit(1);
 
108
    }
 
109
  }
 
110
 
 
111
  while (1)
 
112
  {
 
113
    ret= gearman_worker_work(&worker);
 
114
    if (ret != GEARMAN_SUCCESS)
 
115
    {
 
116
      fprintf(stderr, "%s\n", gearman_worker_error(&worker));
 
117
      break;
 
118
    }
 
119
 
 
120
    if (count > 0)
 
121
    {
 
122
      count--;
 
123
      if (count == 0)
 
124
        break;
 
125
    }
 
126
  }
 
127
 
 
128
  gearman_worker_free(&worker);
 
129
 
 
130
  return 0;
 
131
}
 
132
 
 
133
static void *worker_fn(gearman_job_st *job, void *cb_arg, size_t *result_size,
 
134
                       gearman_return_t *ret_ptr)
 
135
{
 
136
  gearman_benchmark_st *benchmark= (gearman_benchmark_st *)cb_arg;
 
137
 
 
138
  (void)result_size;
 
139
 
 
140
  if (benchmark->verbose > 0)
 
141
    benchmark_check_time(benchmark);
 
142
 
 
143
  if (benchmark->verbose > 1)
 
144
  {
 
145
    printf("Job=%s (%zu)\n", gearman_job_handle(job),
 
146
           gearman_job_workload_size(job));
 
147
  }
 
148
 
 
149
  *ret_ptr= GEARMAN_SUCCESS;
 
150
  return NULL;
 
151
}
 
152
 
 
153
static void usage(char *name)
 
154
{
 
155
  printf("\nusage: %s\n"
 
156
         "\t[-c count] [-f function] [-h <host>] [-p <port>] [-v]\n\n", name);
 
157
  printf("\t-c <count>    - number of jobs to run before exiting\n");
 
158
  printf("\t-f <function> - function name for tasks, can specify many\n"
 
159
         "\t                (default %s)\n",
 
160
                            GEARMAN_BENCHMARK_DEFAULT_FUNCTION);
 
161
  printf("\t-h <host>     - job server host, can specify many\n");
 
162
  printf("\t-p <port>     - job server port\n");
 
163
  printf("\t-v            - increase verbose level\n");
 
164
}