[sgen] Count scanned objects.
[mono.git] / mono / metadata / sgen-protocol.c
1 /*
2  * sgen-protocol.c: Binary protocol of internal activity, to aid
3  * debugging.
4  *
5  * Copyright 2001-2003 Ximian, Inc
6  * Copyright 2003-2010 Novell, Inc.
7  * Copyright (C) 2012 Xamarin Inc
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Library General Public
11  * License 2.0 as published by the Free Software Foundation;
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public
19  * License 2.0 along with this library; if not, write to the Free
20  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21  */
22
23 #ifdef HAVE_SGEN_GC
24
25 #include "config.h"
26 #include "sgen-gc.h"
27 #include "sgen-protocol.h"
28 #include "sgen-memory-governor.h"
29 #include "utils/mono-mmap.h"
30 #include "utils/mono-threads.h"
31
32 #include <errno.h>
33 #ifdef HAVE_UNISTD_H
34 #include <fcntl.h>
35 #endif
36
37 /* FIXME Implement binary protocol IO on systems that don't have unistd */
38 #ifdef HAVE_UNISTD_H
39 /* If valid, dump binary protocol to this file */
40 static int binary_protocol_file = -1;
41
42 /* We set this to -1 to indicate an exclusive lock */
43 static volatile int binary_protocol_use_count = 0;
44
45 #define BINARY_PROTOCOL_BUFFER_SIZE     (65536 - 2 * 8)
46
47 typedef struct _BinaryProtocolBuffer BinaryProtocolBuffer;
48 struct _BinaryProtocolBuffer {
49         BinaryProtocolBuffer * volatile next;
50         volatile int index;
51         unsigned char buffer [BINARY_PROTOCOL_BUFFER_SIZE];
52 };
53
54 static BinaryProtocolBuffer * volatile binary_protocol_buffers = NULL;
55
56 static char* filename_or_prefix = NULL;
57 static int current_file_index = 0;
58 static long long current_file_size = 0;
59 static long long file_size_limit;
60
61 static char*
62 filename_for_index (int index)
63 {
64         char *filename;
65
66         SGEN_ASSERT (0, file_size_limit > 0, "Indexed binary protocol filename must only be used with file size limit");
67
68         filename = sgen_alloc_internal_dynamic (strlen (filename_or_prefix) + 32, INTERNAL_MEM_BINARY_PROTOCOL, TRUE);
69         sprintf (filename, "%s.%d", filename_or_prefix, index);
70
71         return filename;
72 }
73
74 static void
75 free_filename (char *filename)
76 {
77         SGEN_ASSERT (0, file_size_limit > 0, "Indexed binary protocol filename must only be used with file size limit");
78
79         sgen_free_internal_dynamic (filename, strlen (filename_or_prefix) + 32, INTERNAL_MEM_BINARY_PROTOCOL);
80 }
81
82 static void
83 binary_protocol_open_file (void)
84 {
85         char *filename;
86
87         if (file_size_limit > 0)
88                 filename = filename_for_index (current_file_index);
89         else
90                 filename = filename_or_prefix;
91
92         do {
93                 binary_protocol_file = open (filename, O_CREAT|O_WRONLY|O_TRUNC, 0644);
94                 if (binary_protocol_file == -1 && errno != EINTR)
95                         break; /* Failed */
96         } while (binary_protocol_file == -1);
97
98         if (file_size_limit > 0)
99                 free_filename (filename);
100 }
101 #endif
102
103 void
104 binary_protocol_init (const char *filename, long long limit)
105 {
106 #ifdef HAVE_UNISTD_H
107         filename_or_prefix = sgen_alloc_internal_dynamic (strlen (filename) + 1, INTERNAL_MEM_BINARY_PROTOCOL, TRUE);
108         strcpy (filename_or_prefix, filename);
109
110         file_size_limit = limit;
111
112         binary_protocol_open_file ();
113 #endif
114 }
115
116 gboolean
117 binary_protocol_is_enabled (void)
118 {
119 #ifdef HAVE_UNISTD_H
120         return binary_protocol_file != -1;
121 #else
122         return FALSE;
123 #endif
124 }
125
126 #ifdef HAVE_UNISTD_H
127
128 static void
129 close_binary_protocol_file (void)
130 {
131         while (close (binary_protocol_file) == -1 && errno == EINTR)
132                 ;
133         binary_protocol_file = -1;
134 }
135
136 static gboolean
137 try_lock_exclusive (void)
138 {
139         do {
140                 if (binary_protocol_use_count)
141                         return FALSE;
142         } while (InterlockedCompareExchange (&binary_protocol_use_count, -1, 0) != 0);
143         mono_memory_barrier ();
144         return TRUE;
145 }
146
147 static void
148 unlock_exclusive (void)
149 {
150         mono_memory_barrier ();
151         SGEN_ASSERT (0, binary_protocol_use_count == -1, "Exclusively locked count must be -1");
152         if (InterlockedCompareExchange (&binary_protocol_use_count, 0, -1) != -1)
153                 SGEN_ASSERT (0, FALSE, "Somebody messed with the exclusive lock");
154 }
155
156 static void
157 lock_recursive (void)
158 {
159         int old_count;
160         do {
161         retry:
162                 old_count = binary_protocol_use_count;
163                 if (old_count < 0) {
164                         /* Exclusively locked - retry */
165                         /* FIXME: short back-off */
166                         goto retry;
167                 }
168         } while (InterlockedCompareExchange (&binary_protocol_use_count, old_count + 1, old_count) != old_count);
169         mono_memory_barrier ();
170 }
171
172 static void
173 unlock_recursive (void)
174 {
175         int old_count;
176         mono_memory_barrier ();
177         do {
178                 old_count = binary_protocol_use_count;
179                 SGEN_ASSERT (0, old_count > 0, "Locked use count must be at least 1");
180         } while (InterlockedCompareExchange (&binary_protocol_use_count, old_count - 1, old_count) != old_count);
181 }
182
183 static void
184 binary_protocol_flush_buffer (BinaryProtocolBuffer *buffer)
185 {
186         ssize_t ret;
187         size_t to_write = buffer->index;
188         size_t written = 0;
189         g_assert (buffer->index > 0);
190
191         while (written < to_write) {
192                 ret = write (binary_protocol_file, buffer->buffer + written, to_write - written);
193                 if (ret >= 0)
194                         written += ret;
195                 else if (errno == EINTR)
196                         continue;
197                 else
198                         close_binary_protocol_file ();
199         }
200
201         current_file_size += buffer->index;
202
203         sgen_free_os_memory (buffer, sizeof (BinaryProtocolBuffer), SGEN_ALLOC_INTERNAL);
204 }
205
206 static void
207 binary_protocol_check_file_overflow (void)
208 {
209         if (file_size_limit <= 0 || current_file_size < file_size_limit)
210                 return;
211
212         close_binary_protocol_file ();
213
214         if (current_file_index > 0) {
215                 char *filename = filename_for_index (current_file_index - 1);
216                 unlink (filename);
217                 free_filename (filename);
218         }
219
220         ++current_file_index;
221         current_file_size = 0;
222
223         binary_protocol_open_file ();
224 }
225 #endif
226
227 void
228 binary_protocol_flush_buffers (gboolean force)
229 {
230 #ifdef HAVE_UNISTD_H
231         int num_buffers = 0, i;
232         BinaryProtocolBuffer *buf;
233         BinaryProtocolBuffer **bufs;
234
235         if (binary_protocol_file == -1)
236                 return;
237
238         if (!force && !try_lock_exclusive ())
239                 return;
240
241         for (buf = binary_protocol_buffers; buf != NULL; buf = buf->next)
242                 ++num_buffers;
243         bufs = sgen_alloc_internal_dynamic (num_buffers * sizeof (BinaryProtocolBuffer*), INTERNAL_MEM_BINARY_PROTOCOL, TRUE);
244         for (buf = binary_protocol_buffers, i = 0; buf != NULL; buf = buf->next, i++)
245                 bufs [i] = buf;
246         SGEN_ASSERT (0, i == num_buffers, "Binary protocol buffer count error");
247
248         binary_protocol_buffers = NULL;
249
250         for (i = num_buffers - 1; i >= 0; --i) {
251                 binary_protocol_flush_buffer (bufs [i]);
252                 binary_protocol_check_file_overflow ();
253         }
254
255         sgen_free_internal_dynamic (buf, num_buffers * sizeof (BinaryProtocolBuffer*), INTERNAL_MEM_BINARY_PROTOCOL);
256
257         if (!force)
258                 unlock_exclusive ();
259 #endif
260 }
261
262 #ifdef HAVE_UNISTD_H
263 static BinaryProtocolBuffer*
264 binary_protocol_get_buffer (int length)
265 {
266         BinaryProtocolBuffer *buffer, *new_buffer;
267  retry:
268         buffer = binary_protocol_buffers;
269         if (buffer && buffer->index + length <= BINARY_PROTOCOL_BUFFER_SIZE)
270                 return buffer;
271
272         new_buffer = sgen_alloc_os_memory (sizeof (BinaryProtocolBuffer), SGEN_ALLOC_INTERNAL | SGEN_ALLOC_ACTIVATE, "debugging memory");
273         new_buffer->next = buffer;
274         new_buffer->index = 0;
275
276         if (InterlockedCompareExchangePointer ((void**)&binary_protocol_buffers, new_buffer, buffer) != buffer) {
277                 sgen_free_os_memory (new_buffer, sizeof (BinaryProtocolBuffer), SGEN_ALLOC_INTERNAL);
278                 goto retry;
279         }
280
281         return new_buffer;
282 }
283 #endif
284
285 static void
286 protocol_entry (unsigned char type, gpointer data, int size)
287 {
288 #ifdef HAVE_UNISTD_H
289         int index;
290         BinaryProtocolBuffer *buffer;
291
292         if (binary_protocol_file == -1)
293                 return;
294
295         if (sgen_is_worker_thread (mono_native_thread_id_get ()))
296                 type |= 0x80;
297
298         lock_recursive ();
299
300  retry:
301         buffer = binary_protocol_get_buffer (size + 1);
302  retry_same_buffer:
303         index = buffer->index;
304         if (index + 1 + size > BINARY_PROTOCOL_BUFFER_SIZE)
305                 goto retry;
306
307         if (InterlockedCompareExchange (&buffer->index, index + 1 + size, index) != index)
308                 goto retry_same_buffer;
309
310         /* FIXME: if we're interrupted at this point, we have a buffer
311            entry that contains random data. */
312
313         buffer->buffer [index++] = type;
314         memcpy (buffer->buffer + index, data, size);
315         index += size;
316
317         g_assert (index <= BINARY_PROTOCOL_BUFFER_SIZE);
318
319         unlock_recursive ();
320 #endif
321 }
322
323 void
324 binary_protocol_collection_force (int generation)
325 {
326         SGenProtocolCollectionForce entry = { generation };
327         binary_protocol_flush_buffers (FALSE);
328         protocol_entry (SGEN_PROTOCOL_COLLECTION_FORCE, &entry, sizeof (SGenProtocolCollectionForce));
329 }
330
331 void
332 binary_protocol_collection_begin (int index, int generation)
333 {
334         SGenProtocolCollectionBegin entry = { index, generation };
335         binary_protocol_flush_buffers (FALSE);
336         protocol_entry (SGEN_PROTOCOL_COLLECTION_BEGIN, &entry, sizeof (SGenProtocolCollectionBegin));
337 }
338
339 void
340 binary_protocol_collection_end (int index, int generation, long long num_objects_scanned, long long num_unique_objects_scanned)
341 {
342         SGenProtocolCollectionEnd entry = { index, generation, num_objects_scanned, num_unique_objects_scanned };
343         binary_protocol_flush_buffers (FALSE);
344         protocol_entry (SGEN_PROTOCOL_COLLECTION_END, &entry, sizeof (SGenProtocolCollectionEnd));
345 }
346
347 void
348 binary_protocol_concurrent_start (void)
349 {
350         protocol_entry (SGEN_PROTOCOL_CONCURRENT_START, NULL, 0);
351 }
352
353 void
354 binary_protocol_concurrent_update_finish (void)
355 {
356         protocol_entry (SGEN_PROTOCOL_CONCURRENT_UPDATE_FINISH, NULL, 0);
357 }
358
359 void
360 binary_protocol_world_stopping (long long timestamp)
361 {
362         SGenProtocolWorldStopping entry = { timestamp };
363         protocol_entry (SGEN_PROTOCOL_WORLD_STOPPING, &entry, sizeof (SGenProtocolWorldStopping));
364 }
365
366 void
367 binary_protocol_world_stopped (long long timestamp, long long total_major_cards,
368                 long long marked_major_cards, long long total_los_cards, long long marked_los_cards)
369 {
370         SGenProtocolWorldStopped entry = { timestamp, total_major_cards, marked_major_cards, total_los_cards, marked_los_cards };
371         protocol_entry (SGEN_PROTOCOL_WORLD_STOPPED, &entry, sizeof (SGenProtocolWorldStopped));
372 }
373
374 void
375 binary_protocol_world_restarting (int generation, long long timestamp,
376                 long long total_major_cards, long long marked_major_cards, long long total_los_cards, long long marked_los_cards)
377 {
378         SGenProtocolWorldRestarting entry = { generation, timestamp, total_major_cards, marked_major_cards, total_los_cards, marked_los_cards };
379         protocol_entry (SGEN_PROTOCOL_WORLD_RESTARTING, &entry, sizeof (SGenProtocolWorldRestarting));
380 }
381
382 void
383 binary_protocol_world_restarted (int generation, long long timestamp)
384 {
385         SGenProtocolWorldRestarted entry = { generation, timestamp };
386         protocol_entry (SGEN_PROTOCOL_WORLD_RESTARTED, &entry, sizeof (SGenProtocolWorldRestarted));
387 }
388
389 void
390 binary_protocol_thread_suspend (gpointer thread, gpointer stopped_ip)
391 {
392         SGenProtocolThreadSuspend entry = { thread, stopped_ip };
393         protocol_entry (SGEN_PROTOCOL_THREAD_SUSPEND, &entry, sizeof (SGenProtocolThreadSuspend));
394 }
395
396 void
397 binary_protocol_thread_restart (gpointer thread)
398 {
399         SGenProtocolThreadRestart entry = { thread };
400         protocol_entry (SGEN_PROTOCOL_THREAD_RESTART, &entry, sizeof (SGenProtocolThreadRestart));
401 }
402
403 void
404 binary_protocol_thread_register (gpointer thread)
405 {
406         SGenProtocolThreadRegister entry = { thread };
407         protocol_entry (SGEN_PROTOCOL_THREAD_REGISTER, &entry, sizeof (SGenProtocolThreadRegister));
408
409 }
410
411 void
412 binary_protocol_thread_unregister (gpointer thread)
413 {
414         SGenProtocolThreadUnregister entry = { thread };
415         protocol_entry (SGEN_PROTOCOL_THREAD_UNREGISTER, &entry, sizeof (SGenProtocolThreadUnregister));
416
417 }
418
419 void
420 binary_protocol_missing_remset (gpointer obj, gpointer obj_vtable, int offset, gpointer value, gpointer value_vtable, int value_pinned)
421 {
422         SGenProtocolMissingRemset entry = { obj, obj_vtable, offset, value, value_vtable, value_pinned };
423         protocol_entry (SGEN_PROTOCOL_MISSING_REMSET, &entry, sizeof (SGenProtocolMissingRemset));
424
425 }
426
427 void
428 binary_protocol_cement (gpointer obj, gpointer vtable, int size)
429 {
430         SGenProtocolCement entry = { obj, vtable, size };
431         protocol_entry (SGEN_PROTOCOL_CEMENT, &entry, sizeof (SGenProtocolCement));
432 }
433
434 void
435 binary_protocol_cement_reset (void)
436 {
437         protocol_entry (SGEN_PROTOCOL_CEMENT_RESET, NULL, 0);
438 }
439
440 void
441 binary_protocol_domain_unload_begin (gpointer domain)
442 {
443         SGenProtocolDomainUnload entry = { domain };
444         protocol_entry (SGEN_PROTOCOL_DOMAIN_UNLOAD_BEGIN, &entry, sizeof (SGenProtocolDomainUnload));
445 }
446
447 void
448 binary_protocol_domain_unload_end (gpointer domain)
449 {
450         SGenProtocolDomainUnload entry = { domain };
451         protocol_entry (SGEN_PROTOCOL_DOMAIN_UNLOAD_END, &entry, sizeof (SGenProtocolDomainUnload));
452 }
453
454 #ifdef SGEN_HEAVY_BINARY_PROTOCOL
455 void
456 binary_protocol_alloc (gpointer obj, gpointer vtable, int size)
457 {
458         SGenProtocolAlloc entry = { obj, vtable, size };
459         protocol_entry (SGEN_PROTOCOL_ALLOC, &entry, sizeof (SGenProtocolAlloc));
460 }
461
462 void
463 binary_protocol_alloc_pinned (gpointer obj, gpointer vtable, int size)
464 {
465         SGenProtocolAlloc entry = { obj, vtable, size };
466         protocol_entry (SGEN_PROTOCOL_ALLOC_PINNED, &entry, sizeof (SGenProtocolAlloc));
467 }
468
469 void
470 binary_protocol_alloc_degraded (gpointer obj, gpointer vtable, int size)
471 {
472         SGenProtocolAlloc entry = { obj, vtable, size };
473         protocol_entry (SGEN_PROTOCOL_ALLOC_DEGRADED, &entry, sizeof (SGenProtocolAlloc));
474 }
475
476 void
477 binary_protocol_copy (gpointer from, gpointer to, gpointer vtable, int size)
478 {
479         SGenProtocolCopy entry = { from, to, vtable, size };
480         protocol_entry (SGEN_PROTOCOL_COPY, &entry, sizeof (SGenProtocolCopy));
481 }
482
483 void
484 binary_protocol_pin_stage (gpointer addr_ptr, gpointer addr)
485 {
486         SGenProtocolPinStage entry = { addr_ptr, addr };
487         protocol_entry (SGEN_PROTOCOL_PIN_STAGE, &entry, sizeof (SGenProtocolPinStage));
488 }
489
490 void
491 binary_protocol_pin (gpointer obj, gpointer vtable, int size)
492 {
493         SGenProtocolPin entry = { obj, vtable, size };
494         protocol_entry (SGEN_PROTOCOL_PIN, &entry, sizeof (SGenProtocolPin));
495 }
496
497 void
498 binary_protocol_mark (gpointer obj, gpointer vtable, int size)
499 {
500         SGenProtocolMark entry = { obj, vtable, size };
501         protocol_entry (SGEN_PROTOCOL_MARK, &entry, sizeof (SGenProtocolMark));
502 }
503
504 void
505 binary_protocol_scan_begin (gpointer obj, gpointer vtable, int size)
506 {
507         SGenProtocolScanBegin entry = { obj, vtable, size };
508         protocol_entry (SGEN_PROTOCOL_SCAN_BEGIN, &entry, sizeof (SGenProtocolScanBegin));
509 }
510
511 void
512 binary_protocol_scan_vtype_begin (gpointer obj, int size)
513 {
514         SGenProtocolScanVTypeBegin entry = { obj, size };
515         protocol_entry (SGEN_PROTOCOL_SCAN_VTYPE_BEGIN, &entry, sizeof (SGenProtocolScanVTypeBegin));
516 }
517
518 void
519 binary_protocol_wbarrier (gpointer ptr, gpointer value, gpointer value_vtable)
520 {
521         SGenProtocolWBarrier entry = { ptr, value, value_vtable };
522         protocol_entry (SGEN_PROTOCOL_WBARRIER, &entry, sizeof (SGenProtocolWBarrier));
523 }
524
525 void
526 binary_protocol_global_remset (gpointer ptr, gpointer value, gpointer value_vtable)
527 {
528         SGenProtocolGlobalRemset entry = { ptr, value, value_vtable };
529         protocol_entry (SGEN_PROTOCOL_GLOBAL_REMSET, &entry, sizeof (SGenProtocolGlobalRemset));
530 }
531
532 void
533 binary_protocol_ptr_update (gpointer ptr, gpointer old_value, gpointer new_value, gpointer vtable, int size)
534 {
535         SGenProtocolPtrUpdate entry = { ptr, old_value, new_value, vtable, size };
536         protocol_entry (SGEN_PROTOCOL_PTR_UPDATE, &entry, sizeof (SGenProtocolPtrUpdate));
537 }
538
539 void
540 binary_protocol_cleanup (gpointer ptr, gpointer vtable, int size)
541 {
542         SGenProtocolCleanup entry = { ptr, vtable, size };
543         protocol_entry (SGEN_PROTOCOL_CLEANUP, &entry, sizeof (SGenProtocolCleanup));
544 }
545
546 void
547 binary_protocol_empty (gpointer start, int size)
548 {
549         SGenProtocolEmpty entry = { start, size };
550         protocol_entry (SGEN_PROTOCOL_EMPTY, &entry, sizeof (SGenProtocolEmpty));
551 }
552
553 void
554 binary_protocol_card_scan (gpointer start, int size)
555 {
556         SGenProtocolCardScan entry = { start, size };
557         protocol_entry (SGEN_PROTOCOL_CARD_SCAN, &entry, sizeof (SGenProtocolCardScan));
558 }
559
560 void
561 binary_protocol_dislink_update (gpointer link, gpointer obj, int track, int staged)
562 {
563         SGenProtocolDislinkUpdate entry = { link, obj, track, staged };
564         protocol_entry (SGEN_PROTOCOL_DISLINK_UPDATE, &entry, sizeof (SGenProtocolDislinkUpdate));
565 }
566
567 void
568 binary_protocol_dislink_update_staged (gpointer link, gpointer obj, int track, int index)
569 {
570         SGenProtocolDislinkUpdateStaged entry = { link, obj, track, index };
571         protocol_entry (SGEN_PROTOCOL_DISLINK_UPDATE_STAGED, &entry, sizeof (SGenProtocolDislinkUpdateStaged));
572 }
573
574 void
575 binary_protocol_dislink_process_staged (gpointer link, gpointer obj, int index)
576 {
577         SGenProtocolDislinkProcessStaged entry = { link, obj, index };
578         protocol_entry (SGEN_PROTOCOL_DISLINK_PROCESS_STAGED, &entry, sizeof (SGenProtocolDislinkProcessStaged));
579 }
580
581 void
582 binary_protocol_gray_enqueue (gpointer queue, gpointer cursor, gpointer value)
583 {
584         SGenProtocolGrayQueue entry = { queue, cursor, value };
585         protocol_entry (SGEN_PROTOCOL_GRAY_ENQUEUE, &entry, sizeof (SGenProtocolGrayQueue));
586 }
587
588 void
589 binary_protocol_gray_dequeue (gpointer queue, gpointer cursor, gpointer value)
590 {
591         SGenProtocolGrayQueue entry = { queue, cursor, value };
592         protocol_entry (SGEN_PROTOCOL_GRAY_DEQUEUE, &entry, sizeof (SGenProtocolGrayQueue));
593 }
594 #endif
595
596 #endif /* HAVE_SGEN_GC */