zram-perf: Changing zram-perf compressible test pattern

Since zram start supporting to skip compression when hitting
the same pattern in a page, the original test pattern would
not be able to test compression perf. Changing the pattern as
ABCD to get a reasonable test result.

Bug: 119495062
Test: run zram-perf
Change-Id: I58c17687994fa8fe44abe8f32d947b76e434d49a

1 files changed, 42 insertions, 33 deletions

diff --git a/zram-perf/zram-perf.cpp b/zram-perf/zram-perf.cpp
index 32a03ad2..93a2cc15 100644
--- a/zram-perf/zram-perf.cpp
+++ b/zram-perf/zram-perf.cpp
@@ -1,29 +1,38 @@
-#include <iostream>
-#include <chrono>
-#include <numeric>
-#include <sys/types.h>
-#include <sys/stat.h>
 #include <fcntl.h>
 #include <linux/fs.h>
-#include <unistd.h>
+#include <sys/stat.h>
 #include <sys/swap.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <chrono>
+#include <iostream>
+#include <numeric>
+#include <vector>
 
 using namespace std;
 
-const char zram_blkdev_path[] = "/dev/block/zram0";
-const size_t sector_size = 512;
-const size_t page_size = 4096;
+static const size_t kPageSize = sysconf(_SC_PAGESIZE);
+static constexpr char kZramBlkdevPath[] = "/dev/block/zram0";
+static constexpr size_t kPatternSize = 4;
+static constexpr size_t kSectorSize = 512;
 
 void fillPageRand(uint32_t *page) {
-    int start = rand();
-    for (int i = 0; i < page_size / sizeof(int); i++) {
+    uint32_t start = rand();
+    for (int i = 0; i < kPageSize / sizeof(start); i++) {
         page[i] = start+i;
     }
 }
-void fillPageCompressible(uint32_t *page) {
-    int val = rand() & 0xfff;
-    for (int i = 0; i < page_size / sizeof(int); i++) {
-        page[i] = val;
+void fillPageCompressible(void* page) {
+    uint32_t val = rand() & 0xfff;
+    auto page_ptr = reinterpret_cast<typeof(val)*>(page);
+    std::vector<typeof(val)> pattern(kPatternSize, 0);
+
+    for (auto i = 0u; i < kPatternSize; i++) {
+        pattern[i] = val + i;
+    }
+    // fill in ABCD... pattern
+    for (int i = 0; i < kPageSize / sizeof(val); i += kPatternSize) {
+        std::copy_n(pattern.data(), kPatternSize, (page_ptr + i));
     }
 }
 
@@ -51,9 +60,9 @@ public:
         size_t blockSize = 0;
         int result = ioctl(m_fd, BLKGETSIZE, &blockSize);
         if (result < 0) {
-            cout << "ioctl failed" << endl;
+            cout << "ioctl block size failed" << endl;
         }
-        return blockSize * sector_size;
+        return blockSize * kSectorSize;
     }
     ~BlockFd() {
         if (m_fd >= 0) {
@@ -62,11 +71,11 @@ public:
     }
     void fillWithCompressible() {
         size_t devSize = getSize();
-        AlignedAlloc page(page_size, page_size);
-        for (uint64_t offset = 0; offset < devSize; offset += page_size) {
+        AlignedAlloc page(kPageSize, kPageSize);
+        for (uint64_t offset = 0; offset < devSize; offset += kPageSize) {
             fillPageCompressible((uint32_t*)page.ptr());
-            ssize_t ret = write(m_fd, page.ptr(), page_size);
-            if (ret != page_size) {
+            ssize_t ret = write(m_fd, page.ptr(), kPageSize);
+            if (ret != kPageSize) {
                 cout << "write() failed" << endl;
             }
         }
@@ -75,15 +84,15 @@ public:
         chrono::time_point<chrono::high_resolution_clock> start, end;
         size_t devSize = getSize();
         size_t passes = 4;
-        AlignedAlloc page(page_size, page_size);
+        AlignedAlloc page(kPageSize, kPageSize);
 
         start = chrono::high_resolution_clock::now();
         for (int i = 0; i < passes; i++) {
-            for (uint64_t offset = 0; offset < devSize; offset += page_size) {
+            for (uint64_t offset = 0; offset < devSize; offset += kPageSize) {
                 if (offset == 0)
                     lseek(m_fd, offset, SEEK_SET);
-                ssize_t ret = read(m_fd, page.ptr(), page_size);
-                if (ret != page_size) {
+                ssize_t ret = read(m_fd, page.ptr(), kPageSize);
+                if (ret != kPageSize) {
                     cout << "read() failed" << endl;
                 }
             }
@@ -96,16 +105,16 @@ public:
         chrono::time_point<chrono::high_resolution_clock> start, end;
         size_t devSize = getSize();
         size_t passes = 4;
-        AlignedAlloc page(page_size, page_size);
+        AlignedAlloc page(kPageSize, kPageSize);
 
         start = chrono::high_resolution_clock::now();
         for (int i = 0; i < passes; i++) {
-            for (uint64_t offset = 0; offset < devSize; offset += page_size) {
+            for (uint64_t offset = 0; offset < devSize; offset += kPageSize) {
                 fillPageCompressible((uint32_t*)page.ptr());
                 if (offset == 0)
                     lseek(m_fd, offset, SEEK_SET);
-                ssize_t ret = write(m_fd, page.ptr(), page_size);
-                if (ret != page_size) {
+                ssize_t ret = write(m_fd, page.ptr(), kPageSize);
+                if (ret != kPageSize) {
                     cout << "write() failed" << endl;
                 }
             }
@@ -119,7 +128,7 @@ public:
 
 int bench(bool direct)
 {
-    BlockFd zramDev{zram_blkdev_path, direct};
+    BlockFd zramDev{kZramBlkdevPath, direct};
 
     zramDev.fillWithCompressible();
     zramDev.benchSequentialRead();
@@ -129,20 +138,20 @@ int bench(bool direct)
 
 int main(int argc, char *argv[])
 {
-    int result = swapoff(zram_blkdev_path);
+    int result = swapoff(kZramBlkdevPath);
     if (result < 0) {
         cout << "swapoff failed: " << strerror(errno) << endl;
     }
 
     bench(1);
 
-    result = system((string("mkswap ") + string(zram_blkdev_path)).c_str());
+    result = system((string("mkswap ") + string(kZramBlkdevPath)).c_str());
     if (result < 0) {
         cout << "mkswap failed: " <<  strerror(errno) << endl;
         return -1;
     }
 
-    result = swapon(zram_blkdev_path, 0);
+    result = swapon(kZramBlkdevPath, 0);
     if (result < 0) {
         cout << "swapon failed: " <<  strerror(errno) << endl;
         return -1;