add stat counters for allocations

src/core/types.h

@@ -485,13 +485,26 @@ extern "C" PyObject* PystonType_GenericAlloc(BoxedClass* cls, Py_ssize_t nitems)
         return Box::operator new(size, default_cls);                                                                   \
     }
 
+#if STAT_ALLOCATIONS
+#define ALLOC_STATS(cls)                                                                                               \
+    std::string per_name_alloc_name = "alloc." + std::string(cls->tp_name);                                            \
+    std::string per_name_allocsize_name = "allocsize." + std::string(cls->tp_name);                                    \
+    Stats::log(Stats::getStatId(per_name_alloc_name));                                                                 \
+    Stats::log(Stats::getStatId(per_name_allocsize_name), size);
+#else
+#define ALLOC_STATS(cls)
+#endif
+
+
 // The restrictions on when you can use the SIMPLE (ie fast) variant are encoded as
 // asserts in the 1-arg operator new function:
 #define DEFAULT_CLASS_SIMPLE(default_cls)                                                                              \
     void* operator new(size_t size, BoxedClass * cls) __attribute__((visibility("default"))) {                         \
+        ALLOC_STATS(cls);                                                                                              \
         return Box::operator new(size, cls);                                                                           \
     }                                                                                                                  \
     void* operator new(size_t size) __attribute__((visibility("default"))) {                                           \
+        ALLOC_STATS(default_cls);                                                                                      \
         /* In the simple cases, we can inline the following methods and simplify things a lot:                         \
          * - Box::operator new                                                                                         \
          * - cls->tp_alloc                                                                                             \

src/gc/gc_alloc.h

@@ -28,6 +28,7 @@ namespace pyston {
 
 namespace gc {
 
+static StatCounter gc_alloc_bytes("zzz_gc_alloc_bytes");
 extern "C" inline void* gc_alloc(size_t bytes, GCKind kind_id) {
     STAT_TIMER(t0, "us_timer_gc_alloc");
     size_t alloc_bytes = bytes + sizeof(GCAllocation);
@@ -90,8 +91,10 @@ extern "C" inline void* gc_alloc(size_t bytes, GCKind kind_id) {
 
 // if (VERBOSITY()) printf("Allocated %ld bytes at [%p, %p)\n", bytes, r, (char*)r + bytes);
 #endif
-    // printf("Allocated %p\n", r);
 
+#if STAT_ALLOCATIONS
+    gc_alloc_bytes.log(bytes);
+#endif
 
     return r;
 }
@@ -129,6 +132,10 @@ extern "C" inline void* gc_realloc(void* ptr, size_t bytes) {
         alloc->kind_data = bytes;
     }
 
+#if STAT_ALLOCATIONS
+    gc_alloc_bytes.log(bytes);
+#endif
+
     return rtn;
 }
 

src/runtime/types.h

@@ -410,12 +410,37 @@ public:
     size_t size() { return s.size(); }
 
     void* operator new(size_t size, size_t ssize) __attribute__((visibility("default"))) {
+#if STAT_ALLOCATIONS
+        static StatCounter alloc_str("alloc.str");
+        static StatCounter alloc_str1("alloc.str(1)");
+        static StatCounter allocsize_str("allocsize.str");
+
+        if (ssize == 1)
+            alloc_str1.log();
+        else
+            alloc_str.log();
+
+        allocsize_str.log(str_cls->tp_basicsize + ssize + 1);
+#endif
         Box* rtn = static_cast<Box*>(gc_alloc(str_cls->tp_basicsize + ssize + 1, gc::GCKind::PYTHON));
         rtn->cls = str_cls;
         return rtn;
     }
 
     void* operator new(size_t size, BoxedClass* cls, size_t ssize) __attribute__((visibility("default"))) {
+#if STAT_ALLOCATIONS
+        static StatCounter alloc_str("alloc.str");
+        static StatCounter alloc_str1("alloc.str(1)");
+
+        static StatCounter allocsize_str("allocsize.str");
+
+        if (ssize == 1)
+            alloc_str1.log();
+        else
+            alloc_str.log();
+
+        allocsize_str.log(cls->tp_basicsize + ssize + 1);
+#endif
         Box* rtn = static_cast<Box*>(cls->tp_alloc(cls, ssize + 1));
         rtn->cls = cls;
         return rtn;
@@ -517,12 +542,43 @@ public:
     Box** elts;
 
     void* operator new(size_t size, size_t nelts) __attribute__((visibility("default"))) {
+#if STAT_ALLOCATIONS
+        static StatCounter alloc_tuple("alloc.tuple");
+        static StatCounter alloc_tuple0("alloc.tuple(0)");
+
+        static StatCounter allocsize_tuple("allocsize.tuple");
+        static StatCounter allocsize_tuple0("allocsize.tuple(0)");
+
+        if (nelts == 0) {
+            alloc_tuple0.log();
+            allocsize_tuple0.log(_PyObject_VAR_SIZE(tuple_cls, nelts + 1));
+        } else {
+            alloc_tuple.log();
+            allocsize_tuple.log(_PyObject_VAR_SIZE(tuple_cls, nelts + 1));
+        }
+#endif
+
         Box* rtn = static_cast<Box*>(gc_alloc(_PyObject_VAR_SIZE(tuple_cls, nelts + 1), gc::GCKind::PYTHON));
         rtn->cls = tuple_cls;
         return rtn;
     }
 
     void* operator new(size_t size, BoxedClass* cls, size_t nelts) __attribute__((visibility("default"))) {
+#if STAT_ALLOCATIONS
+        static StatCounter alloc_tuple("alloc.tuple");
+        static StatCounter alloc_tuple0("alloc.tuple(0)");
+
+        static StatCounter allocsize_tuple("allocsize.tuple");
+        static StatCounter allocsize_tuple0("allocsize.tuple(0)");
+
+        if (nelts == 0) {
+            alloc_tuple0.log();
+            allocsize_tuple0.log(_PyObject_VAR_SIZE(cls, nelts + 1));
+        } else {
+            alloc_tuple.log();
+            allocsize_tuple.log(_PyObject_VAR_SIZE(cls, nelts + 1));
+        }
+#endif
         Box* rtn = static_cast<Box*>(cls->tp_alloc(cls, nelts));
         rtn->cls = cls;
         return rtn;