Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2024-10-23 22:48:06

0001 #include "PerfTools/AllocMonitor/interface/AllocMonitorBase.h"
0002 #include "PerfTools/AllocMonitor/interface/AllocMonitorRegistry.h"
0003 
0004 #include <iostream>
0005 #include <cassert>
0006 
0007 using namespace cms::perftools;
0008 
0009 namespace {
0010   class TestMonitor : public AllocMonitorBase {
0011   public:
0012     TestMonitor(size_t& iRequested, size_t& iTotal) : requested_(iRequested), total_(iTotal) {}
0013 
0014     void allocCalled(size_t iRequested, size_t iActual, void const*) {
0015       requested_ = iRequested;
0016       total_ += iActual;
0017     }
0018 
0019     void deallocCalled(size_t iActual, void const*) { total_ -= iActual; }
0020 
0021   private:
0022     size_t& requested_;
0023     size_t& total_;
0024   };
0025 }  // namespace
0026 
0027 int main() {
0028   size_t requested = 0;
0029   size_t total = 0;
0030 
0031   {
0032     auto monitor = AllocMonitorRegistry::instance().createAndRegisterMonitor<TestMonitor>(requested, total);
0033     if (requested != 0) {
0034       std::cout << "Memory requested during monitor creation";
0035       exit(1);
0036     }
0037     {
0038       [[maybe_unused]] auto i = std::make_unique<int>(1);
0039       if (requested != sizeof(int)) {
0040         std::cout << "int request size wrong, got " << requested << " expected " << sizeof(int);
0041         exit(1);
0042       }
0043     }
0044     if (total != 0) {
0045       std::cout << "int request not cleaned up";
0046       exit(1);
0047     }
0048 
0049     {
0050       [[maybe_unused]] auto i = new int[5];
0051       if (requested != sizeof(int) * 5) {
0052         std::cout << "int request size wrong, got " << requested << " expected " << sizeof(int) * 5;
0053         exit(1);
0054       }
0055       delete[] i;
0056     }
0057     if (total != 0) {
0058       std::cout << "int request not cleaned up";
0059       exit(1);
0060     }
0061 
0062     {
0063       [[maybe_unused]] auto i = new (std::align_val_t{512}) int;
0064       if (requested != sizeof(int)) {
0065         std::cout << "int request size wrong, got " << requested << " expected " << sizeof(int);
0066         exit(1);
0067       }
0068       delete i;
0069     }
0070     if (total != 0) {
0071       std::cout << "int request not cleaned up";
0072       exit(1);
0073     }
0074 
0075     {
0076       [[maybe_unused]] auto i = new (std::align_val_t{512}) int[5];
0077       if (requested != sizeof(int) * 5) {
0078         std::cout << "int request size wrong, got " << requested << " expected " << sizeof(int) * 5;
0079         exit(1);
0080       }
0081       delete[] i;
0082     }
0083     if (total != 0) {
0084       std::cout << "int request not cleaned up";
0085       exit(1);
0086     }
0087 
0088     {
0089       [[maybe_unused]] auto i = new (std::align_val_t{512}, std::nothrow) int;
0090       if (requested != sizeof(int)) {
0091         std::cout << "int request size wrong, got " << requested << " expected " << sizeof(int);
0092         exit(1);
0093       }
0094       delete i;
0095     }
0096     if (total != 0) {
0097       std::cout << "int request not cleaned up";
0098       exit(1);
0099     }
0100 
0101     {
0102       [[maybe_unused]] auto i = new (std::align_val_t{512}, std::nothrow) int[5];
0103       if (requested != sizeof(int) * 5) {
0104         std::cout << "int request size wrong, got " << requested << " expected " << sizeof(int) * 5;
0105         exit(1);
0106       }
0107       delete[] i;
0108     }
0109     if (total != 0) {
0110       std::cout << "int request not cleaned up";
0111       exit(1);
0112     }
0113 
0114     {
0115       [[maybe_unused]] auto i = new (std::nothrow) int;
0116       if (requested != sizeof(int)) {
0117         std::cout << "int request size wrong, got " << requested << " expected " << sizeof(int);
0118         exit(1);
0119       }
0120       delete i;
0121     }
0122     if (total != 0) {
0123       std::cout << "int request not cleaned up";
0124       exit(1);
0125     }
0126 
0127     {
0128       [[maybe_unused]] auto i = new (std::nothrow) int[5];
0129       if (requested != sizeof(int) * 5) {
0130         std::cout << "int request size wrong, got " << requested << " expected " << sizeof(int) * 5;
0131         exit(1);
0132       }
0133       delete[] i;
0134     }
0135     if (total != 0) {
0136       std::cout << "int request not cleaned up";
0137       exit(1);
0138     }
0139 
0140     {
0141       auto p = calloc(12, 1);
0142       assert(p != nullptr);
0143       {
0144         auto r = requested;
0145         if (r != 12) {
0146           std::cout << "calloc request size wrong, got " << r << " expected " << 12;
0147           exit(1);
0148         }
0149       }
0150       free(p);
0151       if (total != 0) {
0152         std::cout << "calloc request not cleaned up";
0153         exit(1);
0154       }
0155 
0156       p = malloc(50);
0157       assert(p != nullptr);
0158       {
0159         auto r = requested;
0160         if (r != 50) {
0161           std::cout << "malloc request size wrong, got " << r << " expected " << 50;
0162           exit(1);
0163         }
0164       }
0165       p = realloc(p, 100);
0166       assert(p != nullptr);
0167       auto r = requested;
0168       if (r != 100) {
0169         std::cout << "realloc request size wrong, got " << r << " expected " << 100;
0170         exit(1);
0171       }
0172       if (total < 100) {
0173         auto t = total;
0174         std::cout << "realloc request total too small " << t;
0175         exit(1);
0176       }
0177 
0178       free(p);
0179       if (total != 0) {
0180         auto t = total;
0181         std::cout << "free after realloc request not cleaned up, still have " << t;
0182         exit(1);
0183       }
0184 
0185       p = aligned_alloc(128, 128 * 3);
0186       if (requested != 128 * 3) {
0187         auto r = requested;
0188         std::cout << "aligned_alloc request size wrong, got " << r << " expected " << 128 * 3;
0189         exit(1);
0190       }
0191       free(p);
0192       if (total != 0) {
0193         std::cout << "aligned_alloc request not cleaned up";
0194         exit(1);
0195       }
0196 
0197       p = memalign(256, 24);
0198       if (requested != 24) {
0199         auto r = requested;
0200         std::cout << "memalign request size wrong, got " << r << " expected " << 24;
0201         exit(1);
0202       }
0203       free(p);
0204       if (total != 0) {
0205         std::cout << "memalign request not cleaned up";
0206         exit(1);
0207       }
0208 
0209       p = nullptr;
0210       auto ret = posix_memalign(&p, 128, 64);
0211       if (p == nullptr) {
0212         std::cout << "posix_memalign failed to allocate ";
0213         exit(1);
0214       }
0215       if (ret != 0) {
0216         std::cout << "posix_memalign returned failed valued " << ret;
0217         exit(1);
0218       }
0219       if (requested != 64) {
0220         auto r = requested;
0221         std::cout << "posix_memalign request size wrong, got " << r << " expected " << 64;
0222         exit(1);
0223       }
0224       free(p);
0225       if (total != 0) {
0226         std::cout << "posix_memalign request not cleaned up";
0227         exit(1);
0228       }
0229     }
0230     AllocMonitorRegistry::instance().deregisterMonitor(monitor);
0231   }
0232 }