1 files changed, 174 insertions, 174 deletions

diff --git a/erts/emulator/beam/erl_lock_count.c b/erts/emulator/beam/erl_lock_count.c
index c6d8f4df95..c4956d8569 100644
--- a/erts/emulator/beam/erl_lock_count.c
+++ b/erts/emulator/beam/erl_lock_count.c
@@ -20,7 +20,7 @@
 /*
  * Description:	Statistics for locks.
  *
- * Author:	Bj�rn-Egil Dahlberg
+ * Author:	Björn-Egil Dahlberg
  * Date:	2008-07-03
  */
 
@@ -49,7 +49,7 @@ const char *str_undefined = "undefined";
 
 static ethr_tsd_key lcnt_thr_data_key;
 static int lcnt_n_thr;
-static erts_lcnt_thread_data_t *lcnt_thread_data[4096]; 
+static erts_lcnt_thread_data_t *lcnt_thread_data[2048];
 
 /* local functions */
 
@@ -83,12 +83,12 @@ static ERTS_INLINE int lcnt_log2(Uint64 v) {
 
 static char* lcnt_lock_type(Uint16 flag) {
     switch(flag & ERTS_LCNT_LT_ALL) {
-    case ERTS_LCNT_LT_SPINLOCK:	  return "spinlock";
-    case ERTS_LCNT_LT_RWSPINLOCK: return "rw_spinlock";
-    case ERTS_LCNT_LT_MUTEX:      return "mutex";
-    case ERTS_LCNT_LT_RWMUTEX:	  return "rw_mutex";
-    case ERTS_LCNT_LT_PROCLOCK:	  return "proclock";
-    default:                      return "";
+        case ERTS_LCNT_LT_SPINLOCK:   return "spinlock";
+        case ERTS_LCNT_LT_RWSPINLOCK: return "rw_spinlock";
+        case ERTS_LCNT_LT_MUTEX:      return "mutex";
+        case ERTS_LCNT_LT_RWMUTEX:    return "rw_mutex";
+        case ERTS_LCNT_LT_PROCLOCK:   return "proclock";
+        default:                      return "";
     }
 }
 
@@ -116,15 +116,15 @@ static void lcnt_time(erts_lcnt_time_t *time) {
 static void lcnt_time_diff(erts_lcnt_time_t *d, erts_lcnt_time_t *t1, erts_lcnt_time_t *t0) {
     long ds;
     long dns;
-    
+
     ds  = t1->s  - t0->s;
     dns = t1->ns - t0->ns;
-	
+
     /* the difference should not be able to get bigger than 1 sec in ns*/
-    
+
     if (dns < 0) {
-	ds  -= 1;
-	dns += 1000000000LL;
+        ds  -= 1;
+        dns += 1000000000LL;
     }
 
     ASSERT(ds >= 0);
@@ -145,7 +145,7 @@ static void lcnt_time_add(erts_lcnt_time_t *t, erts_lcnt_time_t *d) {
 
 static erts_lcnt_thread_data_t *lcnt_thread_data_alloc(void) {
     erts_lcnt_thread_data_t *eltd;
-   
+
     eltd = (erts_lcnt_thread_data_t*)malloc(sizeof(erts_lcnt_thread_data_t));
     if (!eltd) {
         ERTS_INTERNAL_ERROR("Lock counter failed to allocate memory!");
@@ -164,7 +164,6 @@ static erts_lcnt_thread_data_t *lcnt_get_thread_data(void) {
     return (erts_lcnt_thread_data_t *)ethr_tsd_get(lcnt_thr_data_key);
 }
 
-
 /* debug */
 
 #if 0
@@ -183,15 +182,15 @@ static void print_lock_x(erts_lcnt_lock_t *lock, Uint16 flag, char *action) {
     type = lcnt_lock_type(lock->flag);
     r_state = ethr_atomic_read(&lock->r_state);
     w_state = ethr_atomic_read(&lock->w_state);
-    
+
     if (lock->flag & flag) {
         erts_fprintf(stderr,"%10s [%24s] [r/w state %4ld/%4ld] %2s id %T\r\n",
-		action,
-		lock->name,
-		r_state,
-		w_state,
-		type,
-		lock->id);
+                action,
+                lock->name,
+                r_state,
+                w_state,
+                type,
+                lock->id);
     }
 }
 #endif
@@ -201,18 +200,18 @@ static erts_lcnt_lock_stats_t *lcnt_get_lock_stats(erts_lcnt_lock_t *lock, char
     erts_lcnt_lock_stats_t *stats = NULL;
 
     if (erts_lcnt_rt_options & ERTS_LCNT_OPT_LOCATION) {
-	for (i = 0; i < lock->n_stats; i++) {
-	    if ((lock->stats[i].file == file) && (lock->stats[i].line == line)) {
-		return &(lock->stats[i]);
-	    }
-	}
-	if (lock->n_stats < ERTS_LCNT_MAX_LOCK_LOCATIONS) {
-	    stats = &lock->stats[lock->n_stats];
-	    lock->n_stats++;
-	    stats->file = file;
-	    stats->line = line;
-	    return stats;
-	}
+        for (i = 0; i < lock->n_stats; i++) {
+            if ((lock->stats[i].file == file) && (lock->stats[i].line == line)) {
+                return &(lock->stats[i]);
+            }
+        }
+        if (lock->n_stats < ERTS_LCNT_MAX_LOCK_LOCATIONS) {
+            stats = &lock->stats[lock->n_stats];
+            lock->n_stats++;
+            stats->file = file;
+            stats->line = line;
+            return stats;
+        }
     }
     return &lock->stats[0];
 }
@@ -222,53 +221,48 @@ static void lcnt_update_stats_hist(erts_lcnt_hist_t *hist, erts_lcnt_time_t *tim
     unsigned long r;
 
     if (time_wait->s > 0 || time_wait->ns > ERTS_LCNT_HISTOGRAM_MAX_NS) {
-	idx = ERTS_LCNT_HISTOGRAM_SLOT_SIZE - 1;
+        idx = ERTS_LCNT_HISTOGRAM_SLOT_SIZE - 1;
     } else {
-	r = time_wait->ns >> ERTS_LCNT_HISTOGRAM_RSHIFT;
-	if (r) idx = lcnt_log2(r);
-	else idx = 0;
+        r = time_wait->ns >> ERTS_LCNT_HISTOGRAM_RSHIFT;
+        if (r) idx = lcnt_log2(r);
+        else idx = 0;
     }
     hist->ns[idx]++;
 }
 
 static void lcnt_update_stats(erts_lcnt_lock_stats_t *stats, int lock_in_conflict,
-	                      erts_lcnt_time_t *time_wait) {
-    
+        erts_lcnt_time_t *time_wait) {
+
     ethr_atomic_inc(&stats->tries);
 
     if (lock_in_conflict)
-	ethr_atomic_inc(&stats->colls);
+        ethr_atomic_inc(&stats->colls);
 
     if (time_wait) {
-	lcnt_time_add(&(stats->timer), time_wait);
-	stats->timer_n++;
-	lcnt_update_stats_hist(&stats->hist,time_wait);
+        lcnt_time_add(&(stats->timer), time_wait);
+        stats->timer_n++;
+        lcnt_update_stats_hist(&stats->hist,time_wait);
     }
 }
 
-/* 
- * interface 
- */
+/* interface */
 
 void erts_lcnt_init() {
     erts_lcnt_thread_data_t *eltd = NULL;
-    
+
     /* init lock */
     if (ethr_mutex_init(&lcnt_data_lock) != 0) abort();
 
     /* init tsd */    
     lcnt_n_thr = 0;
-
     ethr_tsd_key_create(&lcnt_thr_data_key,"lcnt_data");
 
     lcnt_lock();
 
-    erts_lcnt_rt_options = ERTS_LCNT_OPT_PROCLOCK | ERTS_LCNT_OPT_LOCATION;
-    
+    erts_lcnt_rt_options = ERTS_LCNT_OPT_LOCATION | ERTS_LCNT_OPT_PROCLOCK;
     eltd = lcnt_thread_data_alloc();
-
     ethr_tsd_set(lcnt_thr_data_key, eltd);
-    
+
     /* init lcnt structure */
     erts_lcnt_data = (erts_lcnt_data_t*)malloc(sizeof(erts_lcnt_data_t));
     if (!erts_lcnt_data) {
@@ -293,7 +287,7 @@ void erts_lcnt_late_init() {
 
 erts_lcnt_lock_list_t *erts_lcnt_list_init(void) {
     erts_lcnt_lock_list_t *list;
-    
+
     list = (erts_lcnt_lock_list_t*)malloc(sizeof(erts_lcnt_lock_list_t));
     if (!list) {
         ERTS_INTERNAL_ERROR("Lock counter failed to allocate memory!");
@@ -307,14 +301,14 @@ erts_lcnt_lock_list_t *erts_lcnt_list_init(void) {
 /* only do this on the list with the deleted locks! */
 void erts_lcnt_list_clear(erts_lcnt_lock_list_t *list) {
     erts_lcnt_lock_t *lock = NULL,
-		     *next = NULL;
+                     *next = NULL;
 
     lock = list->head;
-    
+
     while(lock != NULL) {
-	next = lock->next;
-	free(lock);
-	lock = next;
+        next = lock->next;
+        free(lock);
+        lock = next;
     }
 
     list->head = NULL;
@@ -327,26 +321,25 @@ void erts_lcnt_list_insert(erts_lcnt_lock_list_t *list, erts_lcnt_lock_t *lock)
 
     tail = list->tail;
     if (tail) {
-	tail->next = lock;
-	lock->prev = tail;
+        tail->next = lock;
+        lock->prev = tail;
     } else {
-	list->head = lock;
-	lock->prev = NULL;
-	ASSERT(!lock->next);
+        list->head = lock;
+        lock->prev = NULL;
+        ASSERT(!lock->next);
     }
     lock->next = NULL;
     list->tail = lock;
-    
+
     list->n++;
 }
 
 void erts_lcnt_list_delete(erts_lcnt_lock_list_t *list, erts_lcnt_lock_t *lock) {
-
     if (lock->next) lock->next->prev = lock->prev;
     if (lock->prev) lock->prev->next = lock->next;
     if (list->head == lock) list->head = lock->next;
     if (list->tail == lock) list->tail = lock->prev;
-    
+
     lock->prev = NULL;
     lock->next = NULL;
     list->n--;
@@ -364,12 +357,9 @@ void erts_lcnt_init_lock(erts_lcnt_lock_t *lock, char *name, Uint16 flag ) {
 
 void erts_lcnt_init_lock_x(erts_lcnt_lock_t *lock, char *name, Uint16 flag, Eterm id) { 
     int i;
-    if (!name) {
-	lock->flag = 0;
-	return;
-    }
+    if (name == NULL) { ERTS_LCNT_CLEAR_FLAG(lock); return; }
     lcnt_lock();
-    
+
     lock->next = NULL;
     lock->prev = NULL;
     lock->flag = flag;
@@ -378,46 +368,55 @@ void erts_lcnt_init_lock_x(erts_lcnt_lock_t *lock, char *name, Uint16 flag, Eter
 
     ethr_atomic_init(&lock->r_state, 0);
     ethr_atomic_init(&lock->w_state, 0);
-    
 #ifdef DEBUG
     ethr_atomic_init(&lock->flowstate, 0);
 #endif
-    
+
     lock->n_stats = 1;
 
     for (i = 0; i < ERTS_LCNT_MAX_LOCK_LOCATIONS; i++) {
-	lcnt_clear_stats(&lock->stats[i]);
+        lcnt_clear_stats(&lock->stats[i]);
     }
 
     erts_lcnt_list_insert(erts_lcnt_data->current_locks, lock);
     lcnt_unlock();
 }
-
+/* init empty, instead of zero struct */
+void erts_lcnt_init_lock_empty(erts_lcnt_lock_t *lock) {
+    lock->next = NULL;
+    lock->prev = NULL;
+    lock->flag = 0;
+    lock->name = NULL;
+    lock->id   = NIL;
+    ethr_atomic_init(&lock->r_state, 0);
+    ethr_atomic_init(&lock->w_state, 0);
+#ifdef DEBUG
+    ethr_atomic_init(&lock->flowstate, 0);
+#endif
+    lock->n_stats = 0;
+    sys_memzero(lock->stats, sizeof(lock->stats));
+}
+/* destroy lock */
 void erts_lcnt_destroy_lock(erts_lcnt_lock_t *lock) {
-    erts_lcnt_lock_t *deleted_lock;
-
-    if (!ERTS_LCNT_LOCK_TYPE(lock)) return;
-
+    if (ERTS_LCNT_IS_LOCK_INVALID(lock)) return;
     lcnt_lock();
 
     if (erts_lcnt_rt_options & ERTS_LCNT_OPT_COPYSAVE) {
-	/* copy structure and insert the copy */
-
-	deleted_lock = (erts_lcnt_lock_t*)malloc(sizeof(erts_lcnt_lock_t));
+        erts_lcnt_lock_t *deleted_lock;
+        /* copy structure and insert the copy */
+        deleted_lock = (erts_lcnt_lock_t*)malloc(sizeof(erts_lcnt_lock_t));
         if (!deleted_lock) {
             ERTS_INTERNAL_ERROR("Lock counter failed to allocate memory!");
         }
-	memcpy(deleted_lock, lock, sizeof(erts_lcnt_lock_t));
-
-	deleted_lock->next = NULL;
-	deleted_lock->prev = NULL;
-
-	erts_lcnt_list_insert(erts_lcnt_data->deleted_locks, deleted_lock);
+        memcpy(deleted_lock, lock, sizeof(erts_lcnt_lock_t));
+        deleted_lock->next = NULL;
+        deleted_lock->prev = NULL;
+        erts_lcnt_list_insert(erts_lcnt_data->deleted_locks, deleted_lock);
     }
     /* delete original */
     erts_lcnt_list_delete(erts_lcnt_data->current_locks, lock);
-    lock->flag = 0;
-    
+    ERTS_LCNT_CLEAR_FLAG(lock);
+
     lcnt_unlock();
 }
 
@@ -426,16 +425,15 @@ void erts_lcnt_destroy_lock(erts_lcnt_lock_t *lock) {
 void erts_lcnt_lock_opt(erts_lcnt_lock_t *lock, Uint16 option) {
     erts_aint_t r_state = 0, w_state = 0;
     erts_lcnt_thread_data_t *eltd;
-    
+
     if (erts_lcnt_rt_options & ERTS_LCNT_OPT_SUSPEND) return;
-    if (!ERTS_LCNT_LOCK_TYPE(lock)) return;
+    if (ERTS_LCNT_IS_LOCK_INVALID(lock)) return;
 
     eltd = lcnt_get_thread_data();
-
     ASSERT(eltd);
-    
+
     w_state = ethr_atomic_read(&lock->w_state);
-    
+
     if (option & ERTS_LCNT_LO_WRITE) {
         r_state = ethr_atomic_read(&lock->r_state);
         ethr_atomic_inc( &lock->w_state);
@@ -443,48 +441,47 @@ void erts_lcnt_lock_opt(erts_lcnt_lock_t *lock, Uint16 option) {
     if (option & ERTS_LCNT_LO_READ) {
         ethr_atomic_inc( &lock->r_state);
     }
-    
+
     /* we cannot acquire w_lock if either w or r are taken */
     /* we cannot acquire r_lock if w_lock is taken */	
-    
+
     if ((w_state > 0) || (r_state > 0)) {
-	eltd->lock_in_conflict = 1;
-	if (eltd->timer_set == 0) {
-	    lcnt_time(&eltd->timer);
-	}
-	eltd->timer_set++;
+        eltd->lock_in_conflict = 1;
+        if (eltd->timer_set == 0) {
+            lcnt_time(&eltd->timer);
+        }
+        eltd->timer_set++;
     } else {
-	eltd->lock_in_conflict = 0;
+        eltd->lock_in_conflict = 0;
     }
 }
 
 void erts_lcnt_lock(erts_lcnt_lock_t *lock) {
     erts_aint_t w_state;
     erts_lcnt_thread_data_t *eltd;
-    
+
     if (erts_lcnt_rt_options & ERTS_LCNT_OPT_SUSPEND) return;
-    if (!ERTS_LCNT_LOCK_TYPE(lock)) return;
+    if (ERTS_LCNT_IS_LOCK_INVALID(lock)) return;
 
     w_state = ethr_atomic_read(&lock->w_state);
     ethr_atomic_inc(&lock->w_state);
-
     eltd = lcnt_get_thread_data();
 
     ASSERT(eltd);
 
     if (w_state > 0) {
-	eltd->lock_in_conflict = 1;
-	/* only set the timer if nobody else has it
-	 * This should only happen when proc_locks aquires several locks
-	 * 'atomicly'. All other locks will block the thread if w_state > 0
-	 * i.e. locked.
-	 */
-	if (eltd->timer_set == 0) {
-	    lcnt_time(&eltd->timer);
-	}
-	eltd->timer_set++;
+        eltd->lock_in_conflict = 1;
+        /* only set the timer if nobody else has it
+         * This should only happen when proc_locks aquires several locks
+         * 'atomicly'. All other locks will block the thread if w_state > 0
+         * i.e. locked.
+         */
+        if (eltd->timer_set == 0) {
+            lcnt_time(&eltd->timer);
+        }
+        eltd->timer_set++;
     } else {
-	eltd->lock_in_conflict = 0;
+        eltd->lock_in_conflict = 0;
     }
 }
 
@@ -493,16 +490,19 @@ void erts_lcnt_lock(erts_lcnt_lock_t *lock) {
 void erts_lcnt_lock_unaquire(erts_lcnt_lock_t *lock) {
     /* should check if this thread was "waiting" */
     if (erts_lcnt_rt_options & ERTS_LCNT_OPT_SUSPEND) return;
-    if (!ERTS_LCNT_LOCK_TYPE(lock)) return;
+    if (ERTS_LCNT_IS_LOCK_INVALID(lock)) return;
 
     ethr_atomic_dec(&lock->w_state);
 }
 
-/* erts_lcnt_lock_post
- * used when we get a lock (i.e. directly after a lock operation)
+/*
+ * erts_lcnt_lock_post
+ *
+ * Used when we get a lock (i.e. directly after a lock operation)
  * if the timer was set then we had to wait for the lock
  * lock_post will calculate the wait time.
  */
+
 void erts_lcnt_lock_post(erts_lcnt_lock_t *lock) {
     erts_lcnt_lock_post_x(lock, (char*)str_undefined, 0);
 }
@@ -517,31 +517,31 @@ void erts_lcnt_lock_post_x(erts_lcnt_lock_t *lock, char *file, unsigned int line
 #endif
 
     if (erts_lcnt_rt_options & ERTS_LCNT_OPT_SUSPEND) return;
-    if (!ERTS_LCNT_LOCK_TYPE(lock)) return;
-    
+    if (ERTS_LCNT_IS_LOCK_INVALID(lock)) return;
+
 #ifdef DEBUG
     if (!(lock->flag & (ERTS_LCNT_LT_RWMUTEX | ERTS_LCNT_LT_RWSPINLOCK))) {
-	flowstate = ethr_atomic_read(&lock->flowstate);
-	ASSERT(flowstate == 0);
-	ethr_atomic_inc(&lock->flowstate);
+        flowstate = ethr_atomic_read(&lock->flowstate);
+        ASSERT(flowstate == 0);
+        ethr_atomic_inc(&lock->flowstate);
     }
 #endif
-    
+
     eltd = lcnt_get_thread_data();
-    
+
     ASSERT(eltd);
 
     /* if lock was in conflict, time it */
     stats = lcnt_get_lock_stats(lock, file, line);
     if (eltd->timer_set) {
-	lcnt_time(&timer);
-	
-	lcnt_time_diff(&time_wait, &timer, &(eltd->timer));
-	lcnt_update_stats(stats, eltd->lock_in_conflict, &time_wait);
-	eltd->timer_set--;
-	ASSERT(eltd->timer_set >= 0);
+        lcnt_time(&timer);
+
+        lcnt_time_diff(&time_wait, &timer, &(eltd->timer));
+        lcnt_update_stats(stats, eltd->lock_in_conflict, &time_wait);
+        eltd->timer_set--;
+        ASSERT(eltd->timer_set >= 0);
     } else {
-	lcnt_update_stats(stats, eltd->lock_in_conflict, NULL);
+        lcnt_update_stats(stats, eltd->lock_in_conflict, NULL);
     }
 
 }
@@ -550,27 +550,28 @@ void erts_lcnt_lock_post_x(erts_lcnt_lock_t *lock, char *file, unsigned int line
 
 void erts_lcnt_unlock_opt(erts_lcnt_lock_t *lock, Uint16 option) {
     if (erts_lcnt_rt_options & ERTS_LCNT_OPT_SUSPEND) return;
-    if (!ERTS_LCNT_LOCK_TYPE(lock)) return;
+    if (ERTS_LCNT_IS_LOCK_INVALID(lock)) return;
     if (option & ERTS_LCNT_LO_WRITE) ethr_atomic_dec(&lock->w_state);
     if (option & ERTS_LCNT_LO_READ ) ethr_atomic_dec(&lock->r_state);
 }
 
 void erts_lcnt_unlock(erts_lcnt_lock_t *lock) {
-#ifdef DEBUG
-    erts_aint_t w_state;  
-    erts_aint_t flowstate;
-#endif
     if (erts_lcnt_rt_options & ERTS_LCNT_OPT_SUSPEND) return;
-    if (!ERTS_LCNT_LOCK_TYPE(lock)) return;
+    if (ERTS_LCNT_IS_LOCK_INVALID(lock)) return;
 #ifdef DEBUG
-    /* flowstate */
-    flowstate = ethr_atomic_read(&lock->flowstate);
-    ASSERT(flowstate == 1);
-    ethr_atomic_dec(&lock->flowstate);
-    
-    /* write state */
-    w_state = ethr_atomic_read(&lock->w_state);
-    ASSERT(w_state > 0);
+    {
+        erts_aint_t w_state;  
+        erts_aint_t flowstate;
+
+        /* flowstate */
+        flowstate = ethr_atomic_read(&lock->flowstate);
+        ASSERT(flowstate == 1);
+        ethr_atomic_dec(&lock->flowstate);
+
+        /* write state */
+        w_state = ethr_atomic_read(&lock->w_state);
+        ASSERT(w_state > 0);
+    }
 #endif
     ethr_atomic_dec(&lock->w_state);
 }
@@ -579,35 +580,34 @@ void erts_lcnt_unlock(erts_lcnt_lock_t *lock) {
 
 void erts_lcnt_trylock_opt(erts_lcnt_lock_t *lock, int res, Uint16 option) {
     if (erts_lcnt_rt_options & ERTS_LCNT_OPT_SUSPEND) return;
-    if (!ERTS_LCNT_LOCK_TYPE(lock)) return;
+    if (ERTS_LCNT_IS_LOCK_INVALID(lock)) return;
     /* Determine lock_state via res instead of state */
     if (res != EBUSY) {
-	if (option & ERTS_LCNT_LO_WRITE) ethr_atomic_inc(&lock->w_state);
-	if (option & ERTS_LCNT_LO_READ ) ethr_atomic_inc(&lock->r_state);
-	lcnt_update_stats(&(lock->stats[0]), 0, NULL);
+        if (option & ERTS_LCNT_LO_WRITE) ethr_atomic_inc(&lock->w_state);
+        if (option & ERTS_LCNT_LO_READ ) ethr_atomic_inc(&lock->r_state);
+        lcnt_update_stats(&(lock->stats[0]), 0, NULL);
     } else {
         ethr_atomic_inc(&lock->stats[0].tries);
         ethr_atomic_inc(&lock->stats[0].colls);
     }
 }
 
-   
+
 void erts_lcnt_trylock(erts_lcnt_lock_t *lock, int res) {
     /* Determine lock_state via res instead of state */
-#ifdef DEBUG
-    erts_aint_t flowstate;
-#endif 
     if (erts_lcnt_rt_options & ERTS_LCNT_OPT_SUSPEND) return;
-    if (!ERTS_LCNT_LOCK_TYPE(lock)) return;
+    if (ERTS_LCNT_IS_LOCK_INVALID(lock)) return;
     if (res != EBUSY) {
-	
 #ifdef DEBUG
-	flowstate = ethr_atomic_read(&lock->flowstate);
-	ASSERT(flowstate == 0);
-    	ethr_atomic_inc( &lock->flowstate);
+        {
+            erts_aint_t flowstate;
+            flowstate = ethr_atomic_read(&lock->flowstate);
+            ASSERT(flowstate == 0);
+            ethr_atomic_inc( &lock->flowstate);
+        }
 #endif
-	ethr_atomic_inc(&lock->w_state);
-	lcnt_update_stats(&(lock->stats[0]), 0, NULL);
+        ethr_atomic_inc(&lock->w_state);
+        lcnt_update_stats(&(lock->stats[0]), 0, NULL);
     } else {
         ethr_atomic_inc(&lock->stats[0].tries);
         ethr_atomic_inc(&lock->stats[0].colls);
@@ -662,13 +662,13 @@ void erts_lcnt_clear_counters(void) {
     lcnt_lock();
 
     list = erts_lcnt_data->current_locks;
-    
+
     for (lock = list->head; lock != NULL; lock = lock->next) {
-    	for( i = 0; i < ERTS_LCNT_MAX_LOCK_LOCATIONS; i++) {
-	    stats = &lock->stats[i];
-	    lcnt_clear_stats(stats);
-    	}
-	lock->n_stats = 1;
+        for( i = 0; i < ERTS_LCNT_MAX_LOCK_LOCATIONS; i++) {
+            stats = &lock->stats[i];
+            lcnt_clear_stats(stats);
+        }
+        lock->n_stats = 1;
     }
 
     /* empty deleted locks in lock list */
@@ -681,14 +681,14 @@ void erts_lcnt_clear_counters(void) {
 
 erts_lcnt_data_t *erts_lcnt_get_data(void) {
     erts_lcnt_time_t timer_stop;
-    
+
     lcnt_lock();
-    
+
     lcnt_time(&timer_stop);
     lcnt_time_diff(&(erts_lcnt_data->duration), &timer_stop, &timer_start);
-    
+
     lcnt_unlock();
-    
+
     return erts_lcnt_data;
 }