replace popen with vfork+exec

Author: ccsexyz

cache_simulator.cpp

@@ -19,6 +19,7 @@ typedef struct {
     int enable_fifo;
     int enable_lru;
     int enable_block;
+    int enable_block_v2;
 } config;
 
 static config g_cfg;
@@ -662,9 +663,9 @@ class CacheStatImpl : public CacheStat {
     long last_miss_length_ = 0;
 };
 
-class LRUCache : public Cache, public CacheStatImpl {
+template <typename Impl> class TCache : public Cache, public CacheStatImpl {
 public:
-    LRUCache(size_t cap)
+    TCache(size_t cap)
         : impl_(cap)
     {
     }
@@ -690,70 +691,13 @@ class LRUCache : public Cache, public CacheStatImpl {
     }
 
 private:
-    LRUCacheImpl<string> impl_;
+    Impl impl_;
 };
 
-class FIFOCache : public Cache, public CacheStatImpl {
-public:
-    FIFOCache(size_t cap)
-        : impl_(cap)
-    {
-    }
-
-    void get(const string &key, const size_t length) override
-    {
-        auto [is_hit, old_length] = impl_.get(key);
-        if (!is_hit || old_length != length) {
-            is_hit = false;
-            impl_.set(key, length);
-        }
-        on_get(key, length, is_hit);
-    }
-
-    Stat get_stat() const override
-    {
-        Stat stat;
-        stat.class_name = get_filt_type_name<decltype(*this)>();
-        stat.capacity = impl_.capacity();
-        stat.count = impl_.count();
-        stat.used = impl_.used();
-        return stat;
-    }
-
-private:
-    FIFOCacheImpl<string> impl_;
-};
-
-class BlockCache : public Cache, public CacheStatImpl {
-public:
-    BlockCache(size_t cap)
-        : impl_(cap)
-    {
-    }
-
-    void get(const string &key, const size_t length) override
-    {
-        auto [is_hit, old_length] = impl_.get(key);
-        if (!is_hit || old_length != length) {
-            is_hit = false;
-            impl_.set(key, length);
-        }
-        on_get(key, length, is_hit);
-    }
-
-    Stat get_stat() const override
-    {
-        Stat stat;
-        stat.class_name = get_filt_type_name<decltype(*this)>();
-        stat.capacity = impl_.capacity();
-        stat.count = impl_.count();
-        stat.used = impl_.used();
-        return stat;
-    }
-
-private:
-    BlockCacheImpl<string> impl_;
-};
+using LRUCache = TCache<LRUCacheImpl<string>>;
+using FIFOCache = TCache<FIFOCacheImpl<string>>;
+using BlockCache = TCache<BlockCacheImpl<string>>;
+using BlockCacheV2 = TCache<BlockCacheImplV2<string>>;
 
 vector<string> split(const string &str, const string &delim)
 {
@@ -774,6 +718,7 @@ vector<string> split(const string &str, const string &delim)
 LRUCache *g_lru_cache = nullptr;
 FIFOCache *g_fifo_cache = nullptr;
 BlockCache *g_block_cache = nullptr;
+BlockCacheV2 *g_block_cache_v2 = nullptr;
 
 static void cache_get(const string &key, const long len)
 {
@@ -790,6 +735,10 @@ static void cache_get(const string &key, const long len)
     if (g_cfg.enable_block) {
         g_block_cache->get(key, len);
     }
+
+    if (g_cfg.enable_block_v2) {
+        g_block_cache_v2->get(key, len);
+    }
 }
 
 static void process_line(const string &line)
@@ -855,6 +804,7 @@ static command_t cmds[] = { { "c", "cap", cmd_set_size, offsetof(config, capacit
     { "", "fifo", cmd_set_bool, offsetof(config, enable_fifo), "on" },
     { "", "lru", cmd_set_bool, offsetof(config, enable_lru), "on" },
     { "", "block", cmd_set_bool, offsetof(config, enable_block), "on" },
+    { "", "block_v2", cmd_set_bool, offsetof(config, enable_block_v2), "on" },
     { "", "v2", nullptr, offsetof(config, is_v2), nullptr, "" } };
 
 int main(int argc, const char *argv[])
@@ -869,6 +819,7 @@ int main(int argc, const char *argv[])
     g_lru_cache = new LRUCache(g_cfg.capacity);
     g_fifo_cache = new FIFOCache(g_cfg.capacity);
     g_block_cache = new BlockCache(g_cfg.capacity);
+    g_block_cache_v2 = new BlockCacheV2(g_cfg.capacity);
 
     for (string line; std::getline(std::cin, line);) {
         if (g_cfg.is_v2) {

util.h

@@ -28,6 +28,7 @@ extern "C" {
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
+#include <sys/wait.h>
 #include <time.h>
 #include <unistd.h>
 #include <signal.h>
@@ -665,12 +666,8 @@ time_format(char *buf, size_t cap, time_t now)
 }
 
 static int
-read_command_output(const char *command, char *buf, size_t n)
+read_command_output_popen(const char *command, char *buf, size_t n)
 {
-    if (buf == NULL || n == 0) {
-        return -2;
-    }
-
     FILE *pipe = popen(command, "r");
     if (pipe == NULL) {
         return -1;
@@ -697,6 +694,136 @@ read_command_output(const char *command, char *buf, size_t n)
     return 0;
 }
 
+static char **
+split_cstring(const char *str, const char *sep)
+{
+    if (str_empty(str) || str_empty(sep)) {
+        return NULL;
+    }
+
+    char *dupped_str = strdup(str);
+    size_t lenstr = strlen(dupped_str);
+    str = dupped_str;
+    char **arr = (char **)malloc(sizeof(char *) * (lenstr + 1));
+    char *token = NULL;
+    char *ptr = NULL;
+    int n = 0;
+
+    while ((token = strtok_r((char *)str, sep, &ptr)) != NULL) {
+        str = NULL;
+        arr[n++] = strdup(token);
+    }
+
+    arr[n] = NULL;
+    free(dupped_str);
+
+    return arr;
+}
+
+static void
+do_read_from_fd(int fd, char *buf, size_t n)
+{
+    if (n > 0) {
+        buf[0] = '\0';
+    }
+
+    while (n > 1) {
+        buf[0] = '\0';
+
+        int nr = read(fd, buf, n - 1);
+        if (nr > 0) {
+            buf[nr] = '\0';
+            buf += nr;
+            n -= nr;
+        }
+
+        if (nr <= 0) {
+            break;
+        }
+    }
+}
+
+static int
+read_command_output_impl_2(char **arr, char *buf, size_t n, int fds[2])
+{
+    int r = fds[0];
+    int w = fds[1];
+    int saved_errno = 0;
+
+    pid_t pid = vfork();
+    if (pid < 0) {
+        return -1;
+    }
+
+    if (pid == 0) {
+        // child process
+        close(r);
+
+        // redirect stdout and stderr to fd w
+        if (dup2(w, 1) < 0 || dup2(w, 2) < 0) {
+            saved_errno = errno;
+            _Exit(0);
+        }
+
+        if (execvp(arr[0], arr) < 0) {
+            saved_errno = errno;
+            _Exit(1);
+        }
+    } else {
+        // parent, read output from fd r
+        int dup_ret = dup2(r, w);
+        if (dup_ret >= 0) {
+            do_read_from_fd(r, buf, n);
+        }
+
+        waitpid(pid, NULL, 0);
+
+        if (dup_ret < 0) {
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+static int
+read_command_output_impl_1(const char *command, char *buf, size_t n, int fds[2])
+{
+    char **arr = split_cstring(command, " ");
+    if (arr == NULL) {
+        return -1;
+    }
+
+    int rc = read_command_output_impl_2(arr, buf, n, fds);
+
+    for (int i = 0; arr[i] != NULL; i++) {
+        free(arr[i]);
+    }
+    free(arr);
+
+    return rc;
+}
+
+static int
+read_command_output(const char *command, char *buf, size_t n)
+{
+    if (buf == NULL || n == 0) {
+        return -2;
+    }
+
+    int fds[2];
+    if (pipe(fds) < 0) {
+        return -1;
+    }
+
+    int rc = read_command_output_impl_1(command, buf, n, fds);
+
+    close(fds[0]);
+    close(fds[1]);
+
+    return rc;
+}
+
 typedef struct URI URI;
 
 struct URI {