diff --git a/src/counters.c b/src/counters.c
index 5473b01b4a..6fcd66e23b 100644
--- a/src/counters.c
+++ b/src/counters.c
@@ -140,7 +140,7 @@ void StatsAddUI64(ThreadVars *tv, uint16_t id, uint64_t x)
  * \param id  Index of the counter in the counter array
  * \param pca Counter array that holds the local counters for this TM
  */
-void SCPerfCounterIncr(ThreadVars *tv, uint16_t id)
+void StatsIncr(ThreadVars *tv, uint16_t id)
 {
     SCPerfPrivateContext *pca = &tv->perf_private_ctx;
 #ifdef UNITTESTS
@@ -1432,8 +1432,8 @@ static int SCPerfTestCntArraySize07()
     SCPerfGetAllCountersArray(&tv.perf_public_ctx, &tv.perf_private_ctx);
     pca = &tv.perf_private_ctx;
 
-    SCPerfCounterIncr(&tv, 1);
-    SCPerfCounterIncr(&tv, 2);
+    StatsIncr(&tv, 1);
+    StatsIncr(&tv, 2);
 
     result = pca->size;
 
@@ -1457,7 +1457,7 @@ static int SCPerfTestUpdateCounter08()
     SCPerfGetAllCountersArray(&tv.perf_public_ctx, &tv.perf_private_ctx);
     pca = &tv.perf_private_ctx;
 
-    SCPerfCounterIncr(&tv, id);
+    StatsIncr(&tv, id);
     StatsAddUI64(&tv, id, 100);
 
     result = pca->head[id].value;
@@ -1486,7 +1486,7 @@ static int SCPerfTestUpdateCounter09()
     SCPerfGetAllCountersArray(&tv.perf_public_ctx, &tv.perf_private_ctx);
     pca = &tv.perf_private_ctx;
 
-    SCPerfCounterIncr(&tv, id2);
+    StatsIncr(&tv, id2);
     StatsAddUI64(&tv, id2, 100);
 
     result = (pca->head[id1].value == 0) && (pca->head[id2].value == 101);
@@ -1514,9 +1514,9 @@ static int SCPerfTestUpdateGlobalCounter10()
     SCPerfGetAllCountersArray(&tv.perf_public_ctx, &tv.perf_private_ctx);
     pca = &tv.perf_private_ctx;
 
-    SCPerfCounterIncr(&tv, id1);
+    StatsIncr(&tv, id1);
     StatsAddUI64(&tv, id2, 100);
-    SCPerfCounterIncr(&tv, id3);
+    StatsIncr(&tv, id3);
     StatsAddUI64(&tv, id3, 100);
 
     SCPerfUpdateCounterArray(pca, &tv.perf_public_ctx);
@@ -1549,7 +1549,7 @@ static int SCPerfTestCounterValues11()
     SCPerfGetAllCountersArray(&tv.perf_public_ctx, &tv.perf_private_ctx);
     pca = &tv.perf_private_ctx;
 
-    SCPerfCounterIncr(&tv, id1);
+    StatsIncr(&tv, id1);
     StatsAddUI64(&tv, id2, 256);
     StatsAddUI64(&tv, id3, 257);
     StatsAddUI64(&tv, id4, 16843024);
diff --git a/src/counters.h b/src/counters.h
index 7f463d91c6..693141fd5d 100644
--- a/src/counters.h
+++ b/src/counters.h
@@ -126,7 +126,7 @@ void SCPerfReleasePCA(SCPerfPrivateContext *);
 /* functions used to update local counter values */
 void StatsAddUI64(struct ThreadVars_ *, uint16_t, uint64_t);
 void SCPerfCounterSetUI64(struct ThreadVars_ *, uint16_t, uint64_t);
-void SCPerfCounterIncr(struct ThreadVars_ *, uint16_t);
+void StatsIncr(struct ThreadVars_ *, uint16_t);
 
 #define SCPerfSyncCounters(tv) \
     SCPerfUpdateCounterArray(&(tv)->perf_private_ctx, &(tv)->perf_public_ctx);  \
diff --git a/src/decode-ethernet.c b/src/decode-ethernet.c
index d77b7ac3b3..ee4157236c 100644
--- a/src/decode-ethernet.c
+++ b/src/decode-ethernet.c
@@ -41,7 +41,7 @@
 int DecodeEthernet(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
                    uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_eth);
+    StatsIncr(tv, dtv->counter_eth);
 
     if (unlikely(len < ETHERNET_HEADER_LEN)) {
         ENGINE_SET_INVALID_EVENT(p, ETHERNET_PKT_TOO_SMALL);
diff --git a/src/decode-gre.c b/src/decode-gre.c
index 42459446bd..af4c1af55b 100644
--- a/src/decode-gre.c
+++ b/src/decode-gre.c
@@ -48,7 +48,7 @@ int DecodeGRE(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, ui
     uint16_t header_len = GRE_HDR_LEN;
     GRESreHdr *gsre = NULL;
 
-    SCPerfCounterIncr(tv, dtv->counter_gre);
+    StatsIncr(tv, dtv->counter_gre);
 
     if(len < GRE_HDR_LEN)    {
         ENGINE_SET_INVALID_EVENT(p, GRE_PKT_TOO_SMALL);
diff --git a/src/decode-icmpv4.c b/src/decode-icmpv4.c
index af094e4259..5af012ce9a 100644
--- a/src/decode-icmpv4.c
+++ b/src/decode-icmpv4.c
@@ -153,7 +153,7 @@ void DecodePartialIPV4( Packet* p, uint8_t* partial_packet, uint16_t len )
  */
 int DecodeICMPV4(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_icmpv4);
+    StatsIncr(tv, dtv->counter_icmpv4);
 
     if (len < ICMPV4_HEADER_LEN) {
         ENGINE_SET_INVALID_EVENT(p, ICMPV4_PKT_TOO_SMALL);
diff --git a/src/decode-icmpv6.c b/src/decode-icmpv6.c
index d9bc41db65..7972ea797c 100644
--- a/src/decode-icmpv6.c
+++ b/src/decode-icmpv6.c
@@ -168,7 +168,7 @@ int DecodeICMPV6(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p,
                   uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
     int full_hdr = 0;
-    SCPerfCounterIncr(tv, dtv->counter_icmpv6);
+    StatsIncr(tv, dtv->counter_icmpv6);
 
     if (len < ICMPV6_HEADER_LEN) {
         SCLogDebug("ICMPV6_PKT_TOO_SMALL");
diff --git a/src/decode-ipv4.c b/src/decode-ipv4.c
index a0ca8c173c..856ae5b6d6 100644
--- a/src/decode-ipv4.c
+++ b/src/decode-ipv4.c
@@ -519,7 +519,7 @@ static int DecodeIPV4Packet(Packet *p, uint8_t *pkt, uint16_t len)
 
 int DecodeIPV4(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_ipv4);
+    StatsIncr(tv, dtv->counter_ipv4);
 
     SCLogDebug("pkt %p len %"PRIu16"", pkt, len);
 
diff --git a/src/decode-ipv6.c b/src/decode-ipv6.c
index 12ba7705d9..efd6f10f50 100644
--- a/src/decode-ipv6.c
+++ b/src/decode-ipv6.c
@@ -65,7 +65,7 @@ static void DecodeIPv4inIPv6(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, u
                 PKT_SET_SRC(tp, PKT_SRC_DECODER_IPV6);
                 /* add the tp to the packet queue. */
                 PacketEnqueue(pq,tp);
-                SCPerfCounterIncr(tv, dtv->counter_ipv4inipv6);
+                StatsIncr(tv, dtv->counter_ipv4inipv6);
                 return;
             }
         }
@@ -92,7 +92,7 @@ static int DecodeIP6inIP6(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint
             if (tp != NULL) {
                 PKT_SET_SRC(tp, PKT_SRC_DECODER_IPV6);
                 PacketEnqueue(pq,tp);
-                SCPerfCounterIncr(tv, dtv->counter_ipv6inipv6);
+                StatsIncr(tv, dtv->counter_ipv6inipv6);
             }
         }
     } else {
@@ -601,7 +601,7 @@ int DecodeIPV6(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, u
 {
     int ret;
 
-    SCPerfCounterIncr(tv, dtv->counter_ipv6);
+    StatsIncr(tv, dtv->counter_ipv6);
 
     /* do the actual decoding */
     ret = DecodeIPV6Packet (tv, dtv, p, pkt, len);
diff --git a/src/decode-mpls.c b/src/decode-mpls.c
index f8a77b5831..1569ebfbf6 100644
--- a/src/decode-mpls.c
+++ b/src/decode-mpls.c
@@ -51,7 +51,7 @@ int DecodeMPLS(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt,
     int label;
     int event = 0;
 
-    SCPerfCounterIncr(tv, dtv->counter_mpls);
+    StatsIncr(tv, dtv->counter_mpls);
 
     do {
         if (len < MPLS_HEADER_LEN) {
diff --git a/src/decode-null.c b/src/decode-null.c
index 445a33331c..b3bcb0667c 100644
--- a/src/decode-null.c
+++ b/src/decode-null.c
@@ -47,7 +47,7 @@
 
 int DecodeNull(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_null);
+    StatsIncr(tv, dtv->counter_null);
 
     if (unlikely(len < HDR_SIZE)) {
         ENGINE_SET_INVALID_EVENT(p, LTNULL_PKT_TOO_SMALL);
diff --git a/src/decode-ppp.c b/src/decode-ppp.c
index d6ec902512..f4ea670cfe 100644
--- a/src/decode-ppp.c
+++ b/src/decode-ppp.c
@@ -42,7 +42,7 @@
 
 int DecodePPP(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_ppp);
+    StatsIncr(tv, dtv->counter_ppp);
 
     if (unlikely(len < PPP_HEADER_LEN)) {
         ENGINE_SET_INVALID_EVENT(p, PPP_PKT_TOO_SMALL);
diff --git a/src/decode-pppoe.c b/src/decode-pppoe.c
index 565a9f5894..b6f5031fa7 100644
--- a/src/decode-pppoe.c
+++ b/src/decode-pppoe.c
@@ -49,7 +49,7 @@
  */
 int DecodePPPOEDiscovery(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_pppoe);
+    StatsIncr(tv, dtv->counter_pppoe);
 
     if (len < PPPOE_DISCOVERY_HEADER_MIN_LEN) {
         ENGINE_SET_INVALID_EVENT(p, PPPOE_PKT_TOO_SMALL);
@@ -128,7 +128,7 @@ int DecodePPPOEDiscovery(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8
  */
 int DecodePPPOESession(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_pppoe);
+    StatsIncr(tv, dtv->counter_pppoe);
 
     if (len < PPPOE_SESSION_HEADER_LEN) {
         ENGINE_SET_INVALID_EVENT(p, PPPOE_PKT_TOO_SMALL);
diff --git a/src/decode-raw.c b/src/decode-raw.c
index dc31c944ca..22e1b9e1e9 100644
--- a/src/decode-raw.c
+++ b/src/decode-raw.c
@@ -45,7 +45,7 @@
 
 int DecodeRaw(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_raw);
+    StatsIncr(tv, dtv->counter_raw);
 
     /* If it is ipv4 or ipv6 it should at least be the size of ipv4 */
     if (unlikely(len < IPV4_HEADER_LEN)) {
diff --git a/src/decode-sctp.c b/src/decode-sctp.c
index 2560742125..2d493c6690 100644
--- a/src/decode-sctp.c
+++ b/src/decode-sctp.c
@@ -61,7 +61,7 @@ static int DecodeSCTPPacket(ThreadVars *tv, Packet *p, uint8_t *pkt, uint16_t le
 
 int DecodeSCTP(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_sctp);
+    StatsIncr(tv, dtv->counter_sctp);
 
     if (unlikely(DecodeSCTPPacket(tv, p,pkt,len) < 0)) {
         p->sctph = NULL;
diff --git a/src/decode-sll.c b/src/decode-sll.c
index 0da071da93..eed61a4c39 100644
--- a/src/decode-sll.c
+++ b/src/decode-sll.c
@@ -38,7 +38,7 @@
 
 int DecodeSll(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_sll);
+    StatsIncr(tv, dtv->counter_sll);
 
     if (unlikely(len < SLL_HEADER_LEN)) {
         ENGINE_SET_INVALID_EVENT(p, SLL_PKT_TOO_SMALL);
diff --git a/src/decode-tcp.c b/src/decode-tcp.c
index ae85df48d3..428e7ae4e3 100644
--- a/src/decode-tcp.c
+++ b/src/decode-tcp.c
@@ -186,7 +186,7 @@ static int DecodeTCPPacket(ThreadVars *tv, Packet *p, uint8_t *pkt, uint16_t len
 
 int DecodeTCP(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_tcp);
+    StatsIncr(tv, dtv->counter_tcp);
 
     if (unlikely(DecodeTCPPacket(tv, p,pkt,len) < 0)) {
         SCLogDebug("invalid TCP packet");
diff --git a/src/decode-teredo.c b/src/decode-teredo.c
index ba8cd311b3..b4199a052d 100644
--- a/src/decode-teredo.c
+++ b/src/decode-teredo.c
@@ -96,7 +96,7 @@ int DecodeTeredo(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt,
                     PKT_SET_SRC(tp, PKT_SRC_DECODER_TEREDO);
                     /* add the tp to the packet queue. */
                     PacketEnqueue(pq,tp);
-                    SCPerfCounterIncr(tv, dtv->counter_teredo);
+                    StatsIncr(tv, dtv->counter_teredo);
                     return TM_ECODE_OK;
                 }
             }
diff --git a/src/decode-udp.c b/src/decode-udp.c
index a5be2a4312..14ba7887d3 100644
--- a/src/decode-udp.c
+++ b/src/decode-udp.c
@@ -72,7 +72,7 @@ static int DecodeUDPPacket(ThreadVars *t, Packet *p, uint8_t *pkt, uint16_t len)
 
 int DecodeUDP(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, uint16_t len, PacketQueue *pq)
 {
-    SCPerfCounterIncr(tv, dtv->counter_udp);
+    StatsIncr(tv, dtv->counter_udp);
 
     if (unlikely(DecodeUDPPacket(tv, p,pkt,len) < 0)) {
         p->udph = NULL;
diff --git a/src/decode-vlan.c b/src/decode-vlan.c
index 95eb3e6845..59495594e7 100644
--- a/src/decode-vlan.c
+++ b/src/decode-vlan.c
@@ -61,9 +61,9 @@ int DecodeVLAN(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, uint8_t *pkt, u
     uint32_t proto;
 
     if (p->vlan_idx == 0)
-        SCPerfCounterIncr(tv, dtv->counter_vlan);
+        StatsIncr(tv, dtv->counter_vlan);
     else if (p->vlan_idx == 1)
-        SCPerfCounterIncr(tv, dtv->counter_vlan_qinq);
+        StatsIncr(tv, dtv->counter_vlan_qinq);
 
     if(len < VLAN_HEADER_LEN)    {
         ENGINE_SET_INVALID_EVENT(p, VLAN_HEADER_TOO_SMALL);
diff --git a/src/decode.c b/src/decode.c
index b096bf5753..16f5476b41 100644
--- a/src/decode.c
+++ b/src/decode.c
@@ -106,7 +106,7 @@ void PacketDecodeFinalize(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p)
 {
 
     if (p->flags & PKT_IS_INVALID)
-        SCPerfCounterIncr(tv, dtv->counter_invalid);
+        StatsIncr(tv, dtv->counter_invalid);
 
 #ifdef __SC_CUDA_SUPPORT__
     if (dtv->cuda_vars.mpm_is_cuda)
diff --git a/src/defrag.c b/src/defrag.c
index 0d1ab333dc..7418b93c66 100644
--- a/src/defrag.c
+++ b/src/defrag.c
@@ -771,7 +771,7 @@ insert:
         if (tracker->af == AF_INET) {
             r = Defrag4Reassemble(tv, tracker, p);
             if (r != NULL && tv != NULL && dtv != NULL) {
-                SCPerfCounterIncr(tv, dtv->counter_defrag_ipv4_reassembled);
+                StatsIncr(tv, dtv->counter_defrag_ipv4_reassembled);
                 if (pq && DecodeIPV4(tv, dtv, r, (void *)r->ip4h,
                                IPV4_GET_IPLEN(r), pq) != TM_ECODE_OK) {
                     TmqhOutputPacketpool(tv, r);
@@ -783,7 +783,7 @@ insert:
         else if (tracker->af == AF_INET6) {
             r = Defrag6Reassemble(tv, tracker, p);
             if (r != NULL && tv != NULL && dtv != NULL) {
-                SCPerfCounterIncr(tv, dtv->counter_defrag_ipv6_reassembled);
+                StatsIncr(tv, dtv->counter_defrag_ipv6_reassembled);
                 if (pq && DecodeIPV6(tv, dtv, r, (uint8_t *)r->ip6h,
                                IPV6_GET_PLEN(r) + IPV6_HEADER_LEN,
                                pq) != TM_ECODE_OK) {
@@ -923,10 +923,10 @@ Defrag(ThreadVars *tv, DecodeThreadVars *dtv, Packet *p, PacketQueue *pq)
 
     if (tv != NULL && dtv != NULL) {
         if (af == AF_INET) {
-            SCPerfCounterIncr(tv, dtv->counter_defrag_ipv4_fragments);
+            StatsIncr(tv, dtv->counter_defrag_ipv4_fragments);
         }
         else if (af == AF_INET6) {
-            SCPerfCounterIncr(tv, dtv->counter_defrag_ipv6_fragments);
+            StatsIncr(tv, dtv->counter_defrag_ipv6_fragments);
         }
     }
 
diff --git a/src/flow-manager.c b/src/flow-manager.c
index eca211f09c..4076abdca1 100644
--- a/src/flow-manager.c
+++ b/src/flow-manager.c
@@ -591,7 +591,7 @@ static TmEcode FlowManager(ThreadVars *th_v, void *thread_data)
 
                 SCLogDebug("Flow emergency mode entered...");
 
-                SCPerfCounterIncr(th_v, ftd->flow_emerg_mode_enter);
+                StatsIncr(th_v, ftd->flow_emerg_mode_enter);
             }
         }
 
@@ -662,7 +662,7 @@ static TmEcode FlowManager(ThreadVars *th_v, void *thread_data)
                           "%% flows at the queue", (uintmax_t)ts.tv_sec,
                           (uintmax_t)ts.tv_usec, len * 100 / flow_config.prealloc);
 
-                SCPerfCounterIncr(th_v, ftd->flow_emerg_mode_over);
+                StatsIncr(th_v, ftd->flow_emerg_mode_over);
             } else {
                 flow_update_delay_sec = FLOW_EMERG_MODE_UPDATE_DELAY_SEC;
                 flow_update_delay_nsec = FLOW_EMERG_MODE_UPDATE_DELAY_NSEC;
diff --git a/src/source-af-packet.c b/src/source-af-packet.c
index 1fffe2ba0f..be06b4e95e 100644
--- a/src/source-af-packet.c
+++ b/src/source-af-packet.c
@@ -1852,15 +1852,15 @@ TmEcode DecodeAFP(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Packet
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
-    //SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
+    StatsIncr(tv, dtv->counter_pkts);
+    //StatsIncr(tv, dtv->counter_pkts_per_sec);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
 
     /* If suri has set vlan during reading, we increase vlan counter */
     if (p->vlan_idx) {
-        SCPerfCounterIncr(tv, dtv->counter_vlan);
+        StatsIncr(tv, dtv->counter_vlan);
     }
 
     /* call the decoder */
diff --git a/src/source-erf-dag.c b/src/source-erf-dag.c
index 7394ddd043..f8b6b16b28 100644
--- a/src/source-erf-dag.c
+++ b/src/source-erf-dag.c
@@ -535,7 +535,7 @@ ProcessErfDagRecord(ErfDagThreadVars *ewtn, char *prec)
         p->ts.tv_sec++;
     }
 
-    SCPerfCounterIncr(tv, ewtn->packets);
+    StatsIncr(tv, ewtn->packets);
     ewtn->bytes += wlen;
 
     if (TmThreadsSlotProcessPkt(ewtn->tv, ewtn->slot, p) != TM_ECODE_OK) {
@@ -621,8 +621,8 @@ DecodeErfDag(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq,
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
-    //SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
+    StatsIncr(tv, dtv->counter_pkts);
+    //StatsIncr(tv, dtv->counter_pkts_per_sec);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
diff --git a/src/source-erf-file.c b/src/source-erf-file.c
index 5bc4c38f5c..b1ab61938d 100644
--- a/src/source-erf-file.c
+++ b/src/source-erf-file.c
@@ -284,8 +284,8 @@ DecodeErfFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, PacketQueu
         return TM_ECODE_OK;
 
     /* Update counters. */
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
-    //SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
+    StatsIncr(tv, dtv->counter_pkts);
+    //StatsIncr(tv, dtv->counter_pkts_per_sec);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
diff --git a/src/source-ipfw.c b/src/source-ipfw.c
index 7596546507..3fb8ef3361 100644
--- a/src/source-ipfw.c
+++ b/src/source-ipfw.c
@@ -452,7 +452,7 @@ TmEcode DecodeIPFW(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Packe
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
+    StatsIncr(tv, dtv->counter_pkts);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
diff --git a/src/source-mpipe.c b/src/source-mpipe.c
index 5a9d60eeeb..511e298f1c 100644
--- a/src/source-mpipe.c
+++ b/src/source-mpipe.c
@@ -398,10 +398,10 @@ TmEcode ReceiveMpipeLoop(ThreadVars *tv, void *data, void *slot)
                     if (idesc->be) {
                         /* Buffer Error - No buffer available, so mPipe
                          * dropped the packet. */
-                        SCPerfCounterIncr(tv, XlateStack(ptv, idesc->stack_idx));
+                        StatsIncr(tv, XlateStack(ptv, idesc->stack_idx));
                     } else {
                         /* Bad packet. CRC error */
-                        SCPerfCounterIncr(tv, ptv->mpipe_drop);
+                        StatsIncr(tv, ptv->mpipe_drop);
                         gxio_mpipe_iqueue_drop(iqueue, idesc);
                     }
                     gxio_mpipe_iqueue_release(iqueue, idesc);
@@ -1039,8 +1039,8 @@ TmEcode DecodeMpipe(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq,
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
-//    SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
+    StatsIncr(tv, dtv->counter_pkts);
+//    StatsIncr(tv, dtv->counter_pkts_per_sec);
 
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
 
diff --git a/src/source-napatech.c b/src/source-napatech.c
index ed32ded494..b508e03ac6 100644
--- a/src/source-napatech.c
+++ b/src/source-napatech.c
@@ -357,8 +357,8 @@ TmEcode NapatechDecode(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq,
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
-//    SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
+    StatsIncr(tv, dtv->counter_pkts);
+//    StatsIncr(tv, dtv->counter_pkts_per_sec);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
diff --git a/src/source-netmap.c b/src/source-netmap.c
index e0e5297713..0a96a148f0 100644
--- a/src/source-netmap.c
+++ b/src/source-netmap.c
@@ -930,7 +930,7 @@ static TmEcode DecodeNetmap(ThreadVars *tv, Packet *p, void *data, PacketQueue *
         SCReturnInt(TM_ECODE_OK);
 
     /* update counters */
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
+    StatsIncr(tv, dtv->counter_pkts);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
diff --git a/src/source-nflog.c b/src/source-nflog.c
index f8dc318ce9..d37959807c 100644
--- a/src/source-nflog.c
+++ b/src/source-nflog.c
@@ -499,7 +499,7 @@ TmEcode DecodeNFLOG(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Pack
     IPV6Hdr *ip6h = (IPV6Hdr *)GET_PKT_DATA(p);
     DecodeThreadVars *dtv = (DecodeThreadVars *)data;
 
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
+    StatsIncr(tv, dtv->counter_pkts);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
diff --git a/src/source-nfq.c b/src/source-nfq.c
index ea2bdf83d3..9596ed4538 100644
--- a/src/source-nfq.c
+++ b/src/source-nfq.c
@@ -1223,7 +1223,7 @@ TmEcode DecodeNFQ(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Packet
     if (p->flags & PKT_PSEUDO_STREAM_END)
         return TM_ECODE_OK;
 
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
+    StatsIncr(tv, dtv->counter_pkts);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
diff --git a/src/source-pcap-file.c b/src/source-pcap-file.c
index 7e7b8ba79b..c46c8a6bd7 100644
--- a/src/source-pcap-file.c
+++ b/src/source-pcap-file.c
@@ -401,8 +401,8 @@ TmEcode DecodePcapFile(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, P
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
-    //SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
+    StatsIncr(tv, dtv->counter_pkts);
+    //StatsIncr(tv, dtv->counter_pkts_per_sec);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
diff --git a/src/source-pcap.c b/src/source-pcap.c
index b928318995..aa67b60ada 100644
--- a/src/source-pcap.c
+++ b/src/source-pcap.c
@@ -704,8 +704,8 @@ TmEcode DecodePcap(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Packe
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
-    //SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
+    StatsIncr(tv, dtv->counter_pkts);
+    //StatsIncr(tv, dtv->counter_pkts_per_sec);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
diff --git a/src/source-pfring.c b/src/source-pfring.c
index 6e997be920..6b60df9add 100644
--- a/src/source-pfring.c
+++ b/src/source-pfring.c
@@ -602,15 +602,15 @@ TmEcode DecodePfring(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Pac
         return TM_ECODE_OK;
 
     /* update counters */
-    SCPerfCounterIncr(tv, dtv->counter_pkts);
-    //SCPerfCounterIncr(tv, dtv->counter_pkts_per_sec);
+    StatsIncr(tv, dtv->counter_pkts);
+    //StatsIncr(tv, dtv->counter_pkts_per_sec);
     StatsAddUI64(tv, dtv->counter_bytes, GET_PKT_LEN(p));
     StatsAddUI64(tv, dtv->counter_avg_pkt_size, GET_PKT_LEN(p));
     SCPerfCounterSetUI64(tv, dtv->counter_max_pkt_size, GET_PKT_LEN(p));
 
     /* If suri has set vlan during reading, we increase vlan counter */
     if (p->vlan_idx) {
-        SCPerfCounterIncr(tv, dtv->counter_vlan);
+        StatsIncr(tv, dtv->counter_vlan);
     }
 
     DecodeEthernet(tv, dtv, p, GET_PKT_DATA(p), GET_PKT_LEN(p), pq);
diff --git a/src/stream-tcp-reassemble.c b/src/stream-tcp-reassemble.c
index 839a9ccd55..c0979b9459 100644
--- a/src/stream-tcp-reassemble.c
+++ b/src/stream-tcp-reassemble.c
@@ -1906,7 +1906,7 @@ int StreamTcpReassembleHandleSegmentHandleData(ThreadVars *tv, TcpReassemblyThre
 
     if (stream->flags & STREAMTCP_STREAM_FLAG_DEPTH_REACHED) {
         /* increment stream depth counter */
-        SCPerfCounterIncr(tv, ra_ctx->counter_tcp_stream_depth);
+        StatsIncr(tv, ra_ctx->counter_tcp_stream_depth);
 
         stream->flags |= STREAMTCP_STREAM_FLAG_NOREASSEMBLY;
         SCLogDebug("ssn %p: reassembly depth reached, "
@@ -2607,7 +2607,7 @@ int DoHandleGap(ThreadVars *tv, TcpReassemblyThreadCtx *ra_ctx,
         stream->flags |= STREAMTCP_STREAM_FLAG_GAP;
 
         StreamTcpSetEvent(p, STREAM_REASSEMBLY_SEQ_GAP);
-        SCPerfCounterIncr(tv, ra_ctx->counter_tcp_reass_gap);
+        StatsIncr(tv, ra_ctx->counter_tcp_reass_gap);
 #ifdef DEBUG
         dbg_app_layer_gap++;
 #endif
@@ -2953,7 +2953,7 @@ int StreamTcpReassembleAppLayer (ThreadVars *tv, TcpReassemblyThreadCtx *ra_ctx,
             stream->flags |= STREAMTCP_STREAM_FLAG_GAP;
 
             StreamTcpSetEvent(p, STREAM_REASSEMBLY_SEQ_GAP);
-            SCPerfCounterIncr(tv, ra_ctx->counter_tcp_reass_gap);
+            StatsIncr(tv, ra_ctx->counter_tcp_reass_gap);
 #ifdef DEBUG
             dbg_app_layer_gap++;
 #endif
@@ -3596,7 +3596,7 @@ TcpSegment* StreamTcpGetSegment(ThreadVars *tv, TcpReassemblyThreadCtx *ra_ctx,
                    segment_pool[idx]->allocated);
         /* Increment the counter to show that we are not able to serve the
            segment request due to memcap limit */
-        SCPerfCounterIncr(tv, ra_ctx->counter_tcp_segment_memcap);
+        StatsIncr(tv, ra_ctx->counter_tcp_segment_memcap);
     } else {
         seg->flags = stream_config.segment_init_flags;
         seg->next = NULL;
diff --git a/src/stream-tcp.c b/src/stream-tcp.c
index 00e1e423a5..afc19fc054 100644
--- a/src/stream-tcp.c
+++ b/src/stream-tcp.c
@@ -844,10 +844,10 @@ static int StreamTcpPacketStateNone(ThreadVars *tv, Packet *p,
         if (ssn == NULL) {
             ssn = StreamTcpNewSession(p, stt->ssn_pool_id);
             if (ssn == NULL) {
-                SCPerfCounterIncr(tv, stt->counter_tcp_ssn_memcap);
+                StatsIncr(tv, stt->counter_tcp_ssn_memcap);
                 return -1;
             }
-            SCPerfCounterIncr(tv, stt->counter_tcp_sessions);
+            StatsIncr(tv, stt->counter_tcp_sessions);
         }
         /* set the state */
         StreamTcpPacketSetState(p, ssn, TCP_SYN_RECV);
@@ -925,11 +925,11 @@ static int StreamTcpPacketStateNone(ThreadVars *tv, Packet *p,
         if (ssn == NULL) {
             ssn = StreamTcpNewSession(p, stt->ssn_pool_id);
             if (ssn == NULL) {
-                SCPerfCounterIncr(tv, stt->counter_tcp_ssn_memcap);
+                StatsIncr(tv, stt->counter_tcp_ssn_memcap);
                 return -1;
             }
 
-            SCPerfCounterIncr(tv, stt->counter_tcp_sessions);
+            StatsIncr(tv, stt->counter_tcp_sessions);
         }
 
         /* set the state */
@@ -978,10 +978,10 @@ static int StreamTcpPacketStateNone(ThreadVars *tv, Packet *p,
         if (ssn == NULL) {
             ssn = StreamTcpNewSession(p, stt->ssn_pool_id);
             if (ssn == NULL) {
-                SCPerfCounterIncr(tv, stt->counter_tcp_ssn_memcap);
+                StatsIncr(tv, stt->counter_tcp_ssn_memcap);
                 return -1;
             }
-            SCPerfCounterIncr(tv, stt->counter_tcp_sessions);
+            StatsIncr(tv, stt->counter_tcp_sessions);
         }
         /* set the state */
         StreamTcpPacketSetState(p, ssn, TCP_ESTABLISHED);
@@ -4461,12 +4461,12 @@ int StreamTcpPacket (ThreadVars *tv, Packet *p, StreamTcpThread *stt,
 
     /* update counters */
     if ((p->tcph->th_flags & (TH_SYN|TH_ACK)) == (TH_SYN|TH_ACK)) {
-        SCPerfCounterIncr(tv, stt->counter_tcp_synack);
+        StatsIncr(tv, stt->counter_tcp_synack);
     } else if (p->tcph->th_flags & (TH_SYN)) {
-        SCPerfCounterIncr(tv, stt->counter_tcp_syn);
+        StatsIncr(tv, stt->counter_tcp_syn);
     }
     if (p->tcph->th_flags & (TH_RST)) {
-        SCPerfCounterIncr(tv, stt->counter_tcp_rst);
+        StatsIncr(tv, stt->counter_tcp_rst);
     }
 
     /* broken TCP http://ask.wireshark.org/questions/3183/acknowledgment-number-broken-tcp-the-acknowledge-field-is-nonzero-while-the-ack-flag-is-not-set */
@@ -5020,13 +5020,13 @@ TmEcode StreamTcp (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq, Packe
         return TM_ECODE_OK;
 
     if (p->flow == NULL) {
-        SCPerfCounterIncr(tv, stt->counter_tcp_no_flow);
+        StatsIncr(tv, stt->counter_tcp_no_flow);
         return TM_ECODE_OK;
     }
 
     if (stream_config.flags & STREAMTCP_INIT_FLAG_CHECKSUM_VALIDATION) {
         if (StreamTcpValidateChecksum(p) == 0) {
-            SCPerfCounterIncr(tv, stt->counter_tcp_invalid_checksum);
+            StatsIncr(tv, stt->counter_tcp_invalid_checksum);
             return TM_ECODE_OK;
         }
     } else {
@@ -5864,7 +5864,7 @@ void StreamTcpPseudoPacketCreateStreamEndPacket(ThreadVars *tv, StreamTcpThread
     Packet *np = StreamTcpPseudoSetup(p, GET_PKT_DATA(p), GET_PKT_LEN(p));
     if (np == NULL) {
         SCLogDebug("The packet received from packet allocation is NULL");
-        SCPerfCounterIncr(tv, stt->counter_tcp_pseudo_failed);
+        StatsIncr(tv, stt->counter_tcp_pseudo_failed);
         SCReturn;
     }
     PKT_SET_SRC(np, PKT_SRC_STREAM_TCP_STREAM_END_PSEUDO);
@@ -5899,7 +5899,7 @@ void StreamTcpPseudoPacketCreateStreamEndPacket(ThreadVars *tv, StreamTcpThread
 
     PacketEnqueue(pq, np);
 
-    SCPerfCounterIncr(tv, stt->counter_tcp_pseudo);
+    StatsIncr(tv, stt->counter_tcp_pseudo);
     SCReturn;
 }