lowmem-monitor: Modify PSI memory monitoring levels

The levels of PSI memory monitor changed from 5 levels to 3 levels.
 1. PSI_MEM_LEVEL_LOW (low psi, memory stall is small)
 2. PSI_MEM_LEVEL_MEDIUM
 3. PSI_MEM_LEVEL_HIGH (high psi, memory stall is greater than the aboves)
In accordance with the modification above, stall time also changed.

Code modifications are made to accompany the above modification.

Change-Id: I2bc87ae48a6dd7fc2d019e4a8ebece899c81c747
Signed-off-by: SangYoun Kwak <sy.kwak@samsung.com>

diff --git a/src/resource-limiter/memory/lowmem-monitor-psi.c b/src/resource-limiter/memory/lowmem-monitor-psi.c
index d1eebea..9e3f9e2 100644 (file)
--- a/src/resource-limiter/memory/lowmem-monitor-psi.c
+++ b/src/resource-limiter/memory/lowmem-monitor-psi.c
@@ -38,13 +38,21 @@
 #define BUFF_MAX                               255
 
 #define PSI_PATH                               "/proc/pressure"
-#define PSI_MEMORY_PATH PSI_PATH               "/memory"
+#define PSI_MEMORY_PATH                                PSI_PATH"/memory"
 #define PSI_TYPE_SOME                          "some"
 #define PSI_TYPE_FULL                          "full"
 
+enum psi_mem_level {
+       PSI_MEM_LEVEL_UNKNOWN,
+       PSI_MEM_LEVEL_LOW,
+       PSI_MEM_LEVEL_MEDIUM,
+       PSI_MEM_LEVEL_HIGH,
+       PSI_MEM_LEVEL_MAX,
+};
+
 struct psi_memory_monitor_info {
-       const int mem_level;
-       const char *mem_level_str;
+       const int psi_mem_level;
+       const char *psi_mem_level_str;
        const char *psi_type;
        const int stall_us;
        const int window_us;
@@ -62,17 +70,16 @@ static int g_psi_monitor_epoll_fd = -1;
 static pthread_t g_psi_monitor_thread;
 static int g_psi_monitor_thread_destroy_event_fd = -1;
 
-static void assert_mem_level(int mem_level)
+static void assert_psi_mem_level(int psi_mem_level)
 {
-       switch (mem_level) {
-       case MEM_LEVEL_HIGH:
-       case MEM_LEVEL_MEDIUM:
-       case MEM_LEVEL_LOW:
-       case MEM_LEVEL_CRITICAL:
-       case MEM_LEVEL_OOM:
+       switch (psi_mem_level) {
+       case PSI_MEM_LEVEL_LOW:
+       case PSI_MEM_LEVEL_MEDIUM:
+       case PSI_MEM_LEVEL_HIGH:
                return;
        default:
-               assert("Invalid memory level" && 0);
+               _E("Invalid PSI memory level: %d", psi_mem_level);
+               assert(0);
        }
 }
 
@@ -82,7 +89,7 @@ static void *psi_memory_monitor_handler(struct psi_memory_monitor_info *info)
        unsigned int available_mb;
        int mem_level;
 
-       assert_mem_level(info->mem_level);
+       assert_psi_mem_level(info->psi_mem_level);
 
        available_mb = proc_get_mem_available();
        if (prev_available_mb == available_mb)
@@ -122,7 +129,7 @@ static int register_psi_event_epoll(struct epoll_event_data *event_data)
        assert(event_data);
        info = event_data->data;
        assert(info);
-       assert_mem_level(info->mem_level);
+       assert_psi_mem_level(info->psi_mem_level);
 
        fd = open(PSI_MEMORY_PATH, O_RDWR | O_NONBLOCK);
        if (fd < 0) {
@@ -163,10 +170,10 @@ static int register_psi_event_epoll(struct epoll_event_data *event_data)
                goto error_2;
        }
 
-       _I("PSI event registered(%s %d %d) as %s mem_level", info->psi_type,
+       _I("PSI event registered(%s %d %d) as %s psi_mem_level", info->psi_type,
                                                        info->stall_us,
                                                        info->window_us,
-                                                       info->mem_level_str);
+                                                       info->psi_mem_level_str);
 
        return 0;
 
@@ -174,7 +181,7 @@ error_2:
        close(fd);
        info->fd = -1;
 error_1:
-       _E("Failed to register psi event: mem_level=%s", info->mem_level_str);
+       _E("Failed to register psi event: psi_mem_level=%s", info->psi_mem_level_str);
 
        return RESOURCED_ERROR_FAIL;
 }
@@ -187,7 +194,7 @@ static void unregister_psi_event_epoll(struct epoll_event_data *event_data)
 
        info = event_data->data;
        assert(info);
-       assert_mem_level(info->mem_level);
+       assert_psi_mem_level(info->psi_mem_level);
 
        if (info->fd < 0)
                return;
@@ -265,75 +272,51 @@ static void destroy_psi_monitor_thread(void)
        g_psi_monitor_thread_destroy_event_fd = -1;
 }
 
-static struct psi_memory_monitor_info g_psi_memory_monitor_info_list[MEM_LEVEL_MAX] = {
-       [MEM_LEVEL_HIGH] = {
-               .mem_level = MEM_LEVEL_HIGH,
-               .mem_level_str = "high",
-               .psi_type = PSI_TYPE_SOME,
-               .stall_us = 70000,
-               .window_us = 1000000,
-               .fd = -1,
-       },
-       [MEM_LEVEL_MEDIUM] = {
-               .mem_level = MEM_LEVEL_MEDIUM,
-               .mem_level_str = "medium",
+static struct psi_memory_monitor_info g_psi_memory_monitor_info_list[PSI_MEM_LEVEL_MAX] = {
+       [PSI_MEM_LEVEL_LOW] = {
+               .psi_mem_level = PSI_MEM_LEVEL_LOW,
+               .psi_mem_level_str = "low",
                .psi_type = PSI_TYPE_SOME,
                .stall_us = 70000,
                .window_us = 1000000,
                .fd = -1,
        },
-       [MEM_LEVEL_LOW] = {
-               .mem_level = MEM_LEVEL_LOW,
-               .mem_level_str = "low",
+       [PSI_MEM_LEVEL_MEDIUM] = {
+               .psi_mem_level = PSI_MEM_LEVEL_MEDIUM,
+               .psi_mem_level_str = "medium",
                .psi_type = PSI_TYPE_SOME,
-               .stall_us = 150000,
+               .stall_us = 100000,
                .window_us = 1000000,
                .fd = -1,
        },
-       [MEM_LEVEL_CRITICAL] = {
-               .mem_level = MEM_LEVEL_CRITICAL,
-               .mem_level_str = "critical",
+       [PSI_MEM_LEVEL_HIGH] = {
+               .psi_mem_level = PSI_MEM_LEVEL_HIGH,
+               .psi_mem_level_str = "high",
                .psi_type = PSI_TYPE_FULL,
                .stall_us = 70000,
                .window_us = 1000000,
                .fd = -1,
        },
-       [MEM_LEVEL_OOM] = {
-               .mem_level = MEM_LEVEL_OOM,
-               .mem_level_str = "oom",
-               .psi_type = PSI_TYPE_FULL,
-               .stall_us = 150000,
-               .window_us = 1000000,
-               .fd = -1,
-       }
 };
 
-static struct epoll_event_data g_psi_event_datas[MEM_LEVEL_MAX] = {
-       [MEM_LEVEL_HIGH] = {
+static struct epoll_event_data g_psi_event_datas[PSI_MEM_LEVEL_MAX] = {
+       [PSI_MEM_LEVEL_LOW] = {
                .handler = (epoll_event_handler)psi_memory_monitor_handler,
-               .data = &g_psi_memory_monitor_info_list[MEM_LEVEL_HIGH],
+               .data = &g_psi_memory_monitor_info_list[PSI_MEM_LEVEL_LOW],
        },
-       [MEM_LEVEL_MEDIUM] = {
+       [PSI_MEM_LEVEL_MEDIUM] = {
                .handler = (epoll_event_handler)psi_memory_monitor_handler,
-               .data = &g_psi_memory_monitor_info_list[MEM_LEVEL_MEDIUM],
+               .data = &g_psi_memory_monitor_info_list[PSI_MEM_LEVEL_MEDIUM],
        },
-       [MEM_LEVEL_LOW] = {
+       [PSI_MEM_LEVEL_HIGH] = {
                .handler = (epoll_event_handler)psi_memory_monitor_handler,
-               .data = &g_psi_memory_monitor_info_list[MEM_LEVEL_LOW],
+               .data = &g_psi_memory_monitor_info_list[PSI_MEM_LEVEL_HIGH],
        },
-       [MEM_LEVEL_CRITICAL] = {
-               .handler = (epoll_event_handler)psi_memory_monitor_handler,
-               .data = &g_psi_memory_monitor_info_list[MEM_LEVEL_CRITICAL],
-       },
-       [MEM_LEVEL_OOM] = {
-               .handler = (epoll_event_handler)psi_memory_monitor_handler,
-               .data = &g_psi_memory_monitor_info_list[MEM_LEVEL_OOM],
-       }
 };
 
 static int register_psi_events(void)
 {
-       int mem_level = -1;
+       int psi_mem_level = -1;
 
        g_psi_monitor_epoll_fd = epoll_create(1);
        if (g_psi_monitor_epoll_fd < 0) {
@@ -341,14 +324,14 @@ static int register_psi_events(void)
                return RESOURCED_ERROR_FAIL;
        }
 
-       for (mem_level = MEM_LEVEL_HIGH; mem_level < MEM_LEVEL_MAX; ++mem_level) {
-               if (register_psi_event_epoll(&g_psi_event_datas[mem_level]) < 0)
+       for (psi_mem_level = PSI_MEM_LEVEL_UNKNOWN + 1; psi_mem_level < PSI_MEM_LEVEL_MAX; ++psi_mem_level) {
+               if (register_psi_event_epoll(&g_psi_event_datas[psi_mem_level]) < 0)
                        break;
        }
 
-       if (mem_level < MEM_LEVEL_MAX) {
-               for (mem_level = mem_level - 1; mem_level >= MEM_LEVEL_HIGH; --mem_level)
-                       unregister_psi_event_epoll(&g_psi_event_datas[mem_level]);
+       if (psi_mem_level < PSI_MEM_LEVEL_MAX) {
+               for (psi_mem_level = psi_mem_level - 1; psi_mem_level > PSI_MEM_LEVEL_UNKNOWN; --psi_mem_level)
+                       unregister_psi_event_epoll(&g_psi_event_datas[psi_mem_level]);
                close(g_psi_monitor_epoll_fd);
                g_psi_monitor_epoll_fd = -1;
                return RESOURCED_ERROR_FAIL;
@@ -359,8 +342,8 @@ static int register_psi_events(void)
 
 static void unregister_psi_events(void)
 {
-       for (int mem_level = MEM_LEVEL_HIGH; mem_level < MEM_LEVEL_MAX; ++mem_level)
-               unregister_psi_event_epoll(&g_psi_event_datas[mem_level]);
+       for (int psi_mem_level = PSI_MEM_LEVEL_UNKNOWN + 1; psi_mem_level < PSI_MEM_LEVEL_MAX; ++psi_mem_level)
+               unregister_psi_event_epoll(&g_psi_event_datas[psi_mem_level]);
        close(g_psi_monitor_epoll_fd);
        g_psi_monitor_epoll_fd = -1;
 }