~ubuntu-branches/ubuntu/precise/memcached/precise

« back to all changes in this revision

Viewing changes to memcached_dtrace.d

  • Committer: Bazaar Package Importer
  • Author(s): David Martínez Moreno
  • Date: 2009-10-16 15:09:43 UTC
  • mfrom: (1.3.5 upstream)
  • mto: This revision was merged to the branch mainline in revision 8.
  • Revision ID: james.westby@ubuntu.com-20091016150943-l96biwf7siwdt1ci
Tags: upstream-1.4.2
Import upstream version 1.4.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
22
22
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23
23
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24
24
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25
 
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 
25
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26
26
 */
27
27
provider memcached {
28
28
   /**
29
 
    * Fired when a connection object is allocated from the connection pool
 
29
    * Fired when a connection object is allocated from the connection pool.
30
30
    * @param connid the connection id
31
31
    */
32
32
   probe conn__allocate(int connid);
33
33
 
34
34
   /**
35
 
    * Fired when a connection object is released back to the connection pool
 
35
    * Fired when a connection object is released back to the connection pool.
36
36
    * @param connid the connection id
37
37
    */
38
38
   probe conn__release(int connid);
39
39
 
40
40
   /**
41
 
    * Fired when a new connection object is being created (there is no more
42
 
    * connection objects in the connection pool)
 
41
    * Fired when a new connection object is created (there are no more
 
42
    * connection objects in the connection pool).
43
43
    * @param ptr pointer to the connection object
44
44
    */
45
45
   probe conn__create(void *ptr);
46
46
 
47
47
   /**
48
 
    * Fired when a connection object is being destroyed ("released back to
49
 
    * the memory subsystem")
 
48
    * Fired when a connection object is destroyed ("released back to
 
49
    * the memory subsystem").
50
50
    * @param ptr pointer to the connection object
51
51
    */
52
52
   probe conn__destroy(void *ptr);
60
60
   probe conn__dispatch(int connid, int threadid);
61
61
 
62
62
   /**
63
 
    * Allocate memory from the slab allocator
 
63
    * Allocate memory from the slab allocator.
64
64
    * @param size the requested size
65
65
    * @param slabclass the allocation will be fulfilled in this class
66
66
    * @param slabsize the size of each item in this class
69
69
   probe slabs__allocate(int size, int slabclass, int slabsize, void* ptr);
70
70
 
71
71
   /**
72
 
    * Failed to allocate memory (out of memory)
 
72
    * Failed to allocate memory (out of memory).
73
73
    * @param size the requested size
74
74
    * @param slabclass the class that failed to fulfill the request
75
75
    */
76
76
   probe slabs__allocate__failed(int size, int slabclass);
77
77
 
78
78
   /**
79
 
    * Fired when a slab class needs more space
 
79
    * Fired when a slab class attempts to allocate more space.
80
80
    * @param slabclass class that needs more memory
81
81
    */
82
82
   probe slabs__slabclass__allocate(int slabclass);
83
83
 
84
84
   /**
85
 
    * Failed to allocate memory (out of memory)
 
85
    * Failed to allocate memory (out of memory).
86
86
    * @param slabclass the class that failed grab more memory
87
87
    */
88
88
   probe slabs__slabclass__allocate__failed(int slabclass);
89
89
 
90
90
   /**
91
 
    * Release memory
 
91
    * Release memory.
92
92
    * @param size the size of the memory
93
93
    * @param slabclass the class the memory belongs to
94
94
    * @param ptr pointer to the memory to release
102
102
    * wasting cpu capacity.
103
103
    *
104
104
    * @param key the key searched for
 
105
    * @param keylen length of the key
105
106
    * @param depth the depth in the list of hash table
106
107
    */
107
 
   probe assoc__find(const char *key, int depth);
 
108
   probe assoc__find(const char *key, int keylen, int depth);
108
109
 
109
110
   /**
110
111
    * Fired when a new item has been inserted.
111
112
    * @param key the key just inserted
112
 
    * @param nokeys the total number of keys currently being stored,
 
113
    * @param keylen length of the key
 
114
    * @param nokeys the total number of keys currently stored,
113
115
    *               including the key for which insert was called.
114
116
    */
115
 
   probe assoc__insert(const char *key, int nokeys);
 
117
   probe assoc__insert(const char *key, int keylen, int nokeys);
116
118
 
117
119
   /**
118
120
    * Fired when a new item has been removed.
119
121
    * @param key the key just deleted
120
 
    * @param nokeys the total number of keys currently being stored,
 
122
    * @param keylen length of the key
 
123
    * @param nokeys the total number of keys currently stored,
121
124
    *               excluding the key for which delete was called.
122
125
    */
123
 
   probe assoc__delete(const char *key, int nokeys);
124
 
 
125
 
   /**
126
 
    * Fired when an item is being linked in the cache
127
 
    * @param key the items key
128
 
    * @param size the size of the data
129
 
    */
130
 
   probe item__link(const char *key, int size);
131
 
 
132
 
   /**
133
 
    * Fired when an item is being deleted
134
 
    * @param key the items key
135
 
    * @param size the size of the data
136
 
    */
137
 
   probe item__unlink(const char *key, int size);
138
 
 
139
 
   /**
140
 
    * Fired when the refcount for an item is reduced
141
 
    * @param key the items key
142
 
    * @param size the size of the data
143
 
    */
144
 
   probe item__remove(const char *key, int size);
145
 
 
146
 
   /**
147
 
    * Fired when the "last refenced" time is updated
148
 
    * @param key the items key
149
 
    * @param size the size of the data
150
 
    */
151
 
   probe item__update(const char *key, int size);
152
 
 
153
 
   /**
154
 
    * Fired when an item is bein replaced with another item
 
126
   probe assoc__delete(const char *key, int keylen, int nokeys);
 
127
 
 
128
   /**
 
129
    * Fired when an item is linked into the cache.
 
130
    * @param key the items key
 
131
    * @param keylen length of the key
 
132
    * @param size the size of the data
 
133
    */
 
134
   probe item__link(const char *key, int keylen, int size);
 
135
 
 
136
   /**
 
137
    * Fired when an item is deleted.
 
138
    * @param key the items key
 
139
    * @param keylen length of the key
 
140
    * @param size the size of the data
 
141
    */
 
142
   probe item__unlink(const char *key, int keylen, int size);
 
143
 
 
144
   /**
 
145
    * Fired when the refcount for an item is reduced.
 
146
    * @param key the items key
 
147
    * @param keylen length of the key
 
148
    * @param size the size of the data
 
149
    */
 
150
   probe item__remove(const char *key, int keylen, int size);
 
151
 
 
152
   /**
 
153
    * Fired when the "last refenced" time is updated.
 
154
    * @param key the items key
 
155
    * @param keylen length of the key
 
156
    * @param size the size of the data
 
157
    */
 
158
   probe item__update(const char *key, int keylen, int size);
 
159
 
 
160
   /**
 
161
    * Fired when an item is replaced with another item.
155
162
    * @param oldkey the key of the item to replace
 
163
    * @param oldkeylen the length of the old key
156
164
    * @param oldsize the size of the old item
157
165
    * @param newkey the key of the new item
 
166
    * @param newkeylen the length of the new key
158
167
    * @param newsize the size of the new item
159
168
    */
160
 
   probe item__replace(const char *oldkey, int oldsize, const char *newkey, int newsize);
 
169
   probe item__replace(const char *oldkey, int oldkeylen, int oldsize,
 
170
                       const char *newkey, int newkeylen, int newsize);
161
171
 
162
172
   /**
163
 
    * Fired when the processing of a command starts
 
173
    * Fired when the processing of a command starts.
164
174
    * @param connid the connection id
165
175
    * @param request the incomming request
166
176
    * @param size the size of the request
168
178
   probe process__command__start(int connid, const void *request, int size);
169
179
 
170
180
   /**
171
 
    * Fired when the processing of a command is done
 
181
    * Fired when the processing of a command is done.
172
182
    * @param connid the connection id
173
183
    * @param respnse the response to send back to the client
174
184
    * @param size the size of the response
179
189
    * Fired for a get-command
180
190
    * @param connid connection id
181
191
    * @param key requested key
182
 
    * @param size size of the key's data (or -1 if not found)
183
 
    */
184
 
   probe command__get(int connid, const char *key, int size);
185
 
 
186
 
   /**
187
 
    * Fired for a gets command
188
 
    * @param connid connection id
189
 
    * @param key requested key
190
 
    * @param size size of the key's data (or -1 if not found)
191
 
    * @param casid the casid for the item
192
 
    */
193
 
   probe command__gets(int connid, const char *key, int size, int64_t casid);
194
 
 
195
 
   /**
196
 
    * Fired for a add-command
197
 
    * @param connid connection id
198
 
    * @param key requested key
199
 
    * @param size the new size of the key's data (or -1 if not found)
200
 
    */
201
 
   probe command__add(int connid, const char *key, int size);
202
 
 
203
 
   /**
204
 
    * Fired for a set-command
205
 
    * @param connid connection id
206
 
    * @param key requested key
207
 
    * @param size the new size of the key's data (or -1 if not found)
208
 
    */
209
 
   probe command__set(int connid, const char *key, int size);
210
 
 
211
 
   /**
212
 
    * Fired for a replace-command
213
 
    * @param connid connection id
214
 
    * @param key requested key
215
 
    * @param size the new size of the key's data (or -1 if not found)
216
 
    */
217
 
   probe command__replace(int connid, const char *key, int size);
218
 
 
219
 
   /**
220
 
    * Fired for a prepend-command
221
 
    * @param connid connection id
222
 
    * @param key requested key
223
 
    * @param size the new size of the key's data (or -1 if not found)
224
 
    */
225
 
   probe command__prepend(int connid, const char *key, int size);
226
 
 
227
 
   /**
228
 
    * Fired for a append-command
229
 
    * @param connid connection id
230
 
    * @param key requested key
231
 
    * @param size the new size of the key's data (or -1 if not found)
232
 
    */
233
 
   probe command__append(int connid, const char *key, int size);
234
 
 
235
 
   /**
236
 
    * Fired for a cas-command
237
 
    * @param connid connection id
238
 
    * @param key requested key
239
 
    * @param size size of the key's data (or -1 if not found)
 
192
    * @param keylen length of the key
 
193
    * @param size size of the key's data (or signed int -1 if not found)
 
194
    * @param casid the casid for the item
 
195
    */
 
196
   probe command__get(int connid, const char *key, int keylen, int size, int64_t casid);
 
197
 
 
198
   /**
 
199
    * Fired for an add-command.
 
200
    * @param connid connection id
 
201
    * @param key requested key
 
202
    * @param keylen length of the key
 
203
    * @param size the new size of the key's data (or signed int -1 if
 
204
    *             not found)
 
205
    * @param casid the casid for the item
 
206
    */
 
207
   probe command__add(int connid, const char *key, int keylen, int size, int64_t casid);
 
208
 
 
209
   /**
 
210
    * Fired for a set-command.
 
211
    * @param connid connection id
 
212
    * @param key requested key
 
213
    * @param keylen length of the key
 
214
    * @param size the new size of the key's data (or signed int -1 if
 
215
    *             not found)
 
216
    * @param casid the casid for the item
 
217
    */
 
218
   probe command__set(int connid, const char *key, int keylen, int size, int64_t casid);
 
219
 
 
220
   /**
 
221
    * Fired for a replace-command.
 
222
    * @param connid connection id
 
223
    * @param key requested key
 
224
    * @param keylen length of the key
 
225
    * @param size the new size of the key's data (or signed int -1 if
 
226
    *             not found)
 
227
    * @param casid the casid for the item
 
228
    */
 
229
   probe command__replace(int connid, const char *key, int keylen, int size, int64_t casid);
 
230
 
 
231
   /**
 
232
    * Fired for a prepend-command.
 
233
    * @param connid connection id
 
234
    * @param key requested key
 
235
    * @param keylen length of the key
 
236
    * @param size the new size of the key's data (or signed int -1 if
 
237
    *             not found)
 
238
    * @param casid the casid for the item
 
239
    */
 
240
   probe command__prepend(int connid, const char *key, int keylen, int size, int64_t casid);
 
241
 
 
242
   /**
 
243
    * Fired for an append-command.
 
244
    * @param connid connection id
 
245
    * @param key requested key
 
246
    * @param keylen length of the key
 
247
    * @param size the new size of the key's data (or signed int -1 if
 
248
    *             not found)
 
249
    * @param casid the casid for the item
 
250
    */
 
251
   probe command__append(int connid, const char *key, int keylen, int size, int64_t casid);
 
252
 
 
253
   /**
 
254
    * Fired for a cas-command.
 
255
    * @param connid connection id
 
256
    * @param key requested key
 
257
    * @param keylen length of the key
 
258
    * @param size size of the key's data (or signed int -1 if not found)
240
259
    * @param casid the cas id requested
241
260
    */
242
 
   probe command__cas(int connid, const char *key, int size, int64_t casid);
243
 
 
244
 
   /**
245
 
    * Fired for incr command
246
 
    * @param connid connection id
247
 
    * @param key the requested key
248
 
    * @param val the new value
249
 
    */
250
 
   probe command__incr(int connid, const char *key, int64_t val);
251
 
 
252
 
   /**
253
 
    * Fired for decr command
254
 
    * @param connid connection id
255
 
    * @param key the requested key
256
 
    * @param val the new value
257
 
    */
258
 
   probe command__decr(int connid, const char *key, int64_t val);
259
 
 
260
 
   /**
261
 
    * Fired for a delete command
262
 
    * @param connid connection id
263
 
    * @param key the requested key
264
 
    * @param exptime the expiry time
265
 
    */
266
 
   probe command__delete(int connid, const char *key, long exptime);
 
261
   probe command__cas(int connid, const char *key, int keylen, int size, int64_t casid);
 
262
 
 
263
   /**
 
264
    * Fired for an incr command.
 
265
    * @param connid connection id
 
266
    * @param key the requested key
 
267
    * @param keylen length of the key
 
268
    * @param val the new value
 
269
    */
 
270
   probe command__incr(int connid, const char *key, int keylen, int64_t val);
 
271
 
 
272
   /**
 
273
    * Fired for a decr command.
 
274
    * @param connid connection id
 
275
    * @param key the requested key
 
276
    * @param keylen length of the key
 
277
    * @param val the new value
 
278
    */
 
279
   probe command__decr(int connid, const char *key, int keylen, int64_t val);
 
280
 
 
281
   /**
 
282
    * Fired for a delete command.
 
283
    * @param connid connection id
 
284
    * @param key the requested key
 
285
    * @param keylen length of the key
 
286
    */
 
287
   probe command__delete(int connid, const char *key, int keylen);
267
288
 
268
289
};
269
290