tests/libxrpl/basics/MallocTrim.cpp

#include <xrpl/basics/MallocTrim.h>
 
#include <xrpl/beast/utility/Journal.h>
 
#include <boost/predef.h>
 
#include <gtest/gtest.h>
 
#include <string>
 
using namespace xrpl;
 
// cSpell:ignore statm
 
#if defined(__GLIBC__) && BOOST_OS_LINUX
namespace xrpl::detail {
long
parseStatmRSSkB(std::string const& statm);
}  // namespace xrpl::detail
#endif
 
TEST(MallocTrimReport, structure)
{
    // Test default construction
    MallocTrimReport report;
    EXPECT_EQ(report.supported, false);
    EXPECT_EQ(report.trimResult, -1);
    EXPECT_EQ(report.rssBeforeKB, -1);
    EXPECT_EQ(report.rssAfterKB, -1);
    EXPECT_EQ(report.durationUs, std::chrono::microseconds{-1});
    EXPECT_EQ(report.minfltDelta, -1);
    EXPECT_EQ(report.majfltDelta, -1);
    EXPECT_EQ(report.deltaKB(), 0);
 
    // Test deltaKB calculation - memory freed
    report.rssBeforeKB = 1000;
    report.rssAfterKB = 800;
    EXPECT_EQ(report.deltaKB(), -200);
 
    // Test deltaKB calculation - memory increased
    report.rssBeforeKB = 500;
    report.rssAfterKB = 600;
    EXPECT_EQ(report.deltaKB(), 100);
 
    // Test deltaKB calculation - no change
    report.rssBeforeKB = 1234;
    report.rssAfterKB = 1234;
    EXPECT_EQ(report.deltaKB(), 0);
}
 
#if defined(__GLIBC__) && BOOST_OS_LINUX
TEST(parseStatmRSSkB, standard_format)
{
    using xrpl::detail::parseStatmRSSkB;
 
    // Test standard format: size resident shared text lib data dt
    // Assuming 4KB page size: resident=1000 pages = 4000 KB
    {
        std::string const statm = "25365 1000 2377 0 0 5623 0";
        long const result = parseStatmRSSkB(statm);
        // Note: actual result depends on system page size
        // On most systems it's 4KB, so 1000 pages = 4000 KB
        EXPECT_GT(result, 0);
    }
 
    // Test with newline
    {
        std::string const statm = "12345 2000 1234 0 0 3456 0\n";
        long const result = parseStatmRSSkB(statm);
        EXPECT_GT(result, 0);
    }
 
    // Test with tabs
    {
        std::string const statm = "12345\t2000\t1234\t0\t0\t3456\t0";
        long const result = parseStatmRSSkB(statm);
        EXPECT_GT(result, 0);
    }
 
    // Test zero resident pages
    {
        std::string const statm = "25365 0 2377 0 0 5623 0";
        long const result = parseStatmRSSkB(statm);
        EXPECT_EQ(result, 0);
    }
 
    // Test with extra whitespace
    {
        std::string const statm = "  25365   1000   2377  ";
        long const result = parseStatmRSSkB(statm);
        EXPECT_GT(result, 0);
    }
 
    // Test empty string
    {
        std::string const statm;
        long const result = parseStatmRSSkB(statm);
        EXPECT_EQ(result, -1);
    }
 
    // Test malformed data (only one field)
    {
        std::string const statm = "25365";
        long const result = parseStatmRSSkB(statm);
        EXPECT_EQ(result, -1);
    }
 
    // Test malformed data (non-numeric)
    {
        std::string const statm = "abc def ghi";
        long const result = parseStatmRSSkB(statm);
        EXPECT_EQ(result, -1);
    }
 
    // Test malformed data (second field non-numeric)
    {
        std::string const statm = "25365 abc 2377";
        long const result = parseStatmRSSkB(statm);
        EXPECT_EQ(result, -1);
    }
}
#endif
 
TEST(mallocTrim, without_debug_logging)
{
    beast::Journal const journal{beast::Journal::getNullSink()};
 
    MallocTrimReport const report = mallocTrim("without_debug", journal);
 
#if defined(__GLIBC__) && BOOST_OS_LINUX
    EXPECT_EQ(report.supported, true);
    EXPECT_GE(report.trimResult, 0);
    EXPECT_EQ(report.durationUs, std::chrono::microseconds{-1});
    EXPECT_EQ(report.minfltDelta, -1);
    EXPECT_EQ(report.majfltDelta, -1);
#else
    EXPECT_EQ(report.supported, false);
    EXPECT_EQ(report.trimResult, -1);
    EXPECT_EQ(report.rssBeforeKB, -1);
    EXPECT_EQ(report.rssAfterKB, -1);
    EXPECT_EQ(report.durationUs, std::chrono::microseconds{-1});
    EXPECT_EQ(report.minfltDelta, -1);
    EXPECT_EQ(report.majfltDelta, -1);
#endif
}
 
TEST(mallocTrim, empty_tag)
{
    beast::Journal const journal{beast::Journal::getNullSink()};
    MallocTrimReport const report = mallocTrim("", journal);
 
#if defined(__GLIBC__) && BOOST_OS_LINUX
    EXPECT_EQ(report.supported, true);
    EXPECT_GE(report.trimResult, 0);
#else
    EXPECT_EQ(report.supported, false);
#endif
}
 
TEST(mallocTrim, with_debug_logging)
{
    struct DebugSink : public beast::Journal::Sink
    {
        DebugSink() : Sink(beast::Severity::Debug, false)
        {
        }
        void
        write(beast::Severity, std::string const&) override
        {
        }
        void
        writeAlways(beast::Severity, std::string const&) override
        {
        }
    };
 
    DebugSink sink;
    beast::Journal const journal{sink};
 
    MallocTrimReport const report = mallocTrim("debug_test", journal);
 
#if defined(__GLIBC__) && BOOST_OS_LINUX
    EXPECT_EQ(report.supported, true);
    EXPECT_GE(report.trimResult, 0);
    EXPECT_GE(report.durationUs.count(), 0);
    EXPECT_GE(report.minfltDelta, 0);
    EXPECT_GE(report.majfltDelta, 0);
#else
    EXPECT_EQ(report.supported, false);
    EXPECT_EQ(report.trimResult, -1);
    EXPECT_EQ(report.durationUs, std::chrono::microseconds{-1});
    EXPECT_EQ(report.minfltDelta, -1);
    EXPECT_EQ(report.majfltDelta, -1);
#endif
}
 
TEST(mallocTrim, repeated_calls)
{
    beast::Journal const journal{beast::Journal::getNullSink()};
 
    // Call malloc_trim multiple times to ensure it's safe
    for (int i = 0; i < 5; ++i)
    {
        MallocTrimReport const report = mallocTrim("iteration_" + std::to_string(i), journal);
 
#if defined(__GLIBC__) && BOOST_OS_LINUX
        EXPECT_EQ(report.supported, true);
        EXPECT_GE(report.trimResult, 0);
#else
        EXPECT_EQ(report.supported, false);
#endif
    }
}