add prefix to cache line macros
[dpdk.git] / app / test / test_memzone.c
index 42c7601..5da6903 100644 (file)
@@ -133,6 +133,8 @@ test_memzone_reserve_flags(void)
        const struct rte_memseg *ms;
        int hugepage_2MB_avail = 0;
        int hugepage_1GB_avail = 0;
+       int hugepage_16MB_avail = 0;
+       int hugepage_16GB_avail = 0;
        const size_t size = 100;
        int i = 0;
        ms = rte_eal_get_physmem_layout();
@@ -141,12 +143,20 @@ test_memzone_reserve_flags(void)
                        hugepage_2MB_avail = 1;
                if (ms[i].hugepage_sz == RTE_PGSIZE_1G)
                        hugepage_1GB_avail = 1;
+               if (ms[i].hugepage_sz == RTE_PGSIZE_16M)
+                       hugepage_16MB_avail = 1;
+               if (ms[i].hugepage_sz == RTE_PGSIZE_16G)
+                       hugepage_16GB_avail = 1;
        }
-       /* Display the availability of 2MB and 1GB pages */
+       /* Display the availability of 2MB ,1GB, 16MB, 16GB pages */
        if (hugepage_2MB_avail)
                printf("2MB Huge pages available\n");
        if (hugepage_1GB_avail)
                printf("1GB Huge pages available\n");
+       if (hugepage_16MB_avail)
+               printf("16MB Huge pages available\n");
+       if (hugepage_16GB_avail)
+               printf("16GB Huge pages available\n");
        /*
         * If 2MB pages available, check that a small memzone is correctly
         * reserved from 2MB huge pages when requested by the RTE_MEMZONE_2MB flag.
@@ -255,6 +265,117 @@ test_memzone_reserve_flags(void)
                        }
                }
        }
+       /*
+        * This option is for IBM Power. If 16MB pages available, check
+        * that a small memzone is correctly reserved from 16MB huge pages
+        * when requested by the RTE_MEMZONE_16MB flag. Also check that
+        * RTE_MEMZONE_SIZE_HINT_ONLY flag only defaults to an available
+        * page size (i.e 16GB ) when 16MB pages are unavailable.
+        */
+       if (hugepage_16MB_avail) {
+               mz = rte_memzone_reserve("flag_zone_16M", size, SOCKET_ID_ANY,
+                               RTE_MEMZONE_16MB);
+               if (mz == NULL) {
+                       printf("MEMZONE FLAG 16MB\n");
+                       return -1;
+               }
+               if (mz->hugepage_sz != RTE_PGSIZE_16M) {
+                       printf("hugepage_sz not equal 16M\n");
+                       return -1;
+               }
+
+               mz = rte_memzone_reserve("flag_zone_16M_HINT", size,
+               SOCKET_ID_ANY, RTE_MEMZONE_16MB|RTE_MEMZONE_SIZE_HINT_ONLY);
+               if (mz == NULL) {
+                       printf("MEMZONE FLAG 2MB\n");
+                       return -1;
+               }
+               if (mz->hugepage_sz != RTE_PGSIZE_16M) {
+                       printf("hugepage_sz not equal 16M\n");
+                       return -1;
+               }
+
+               /* Check if 1GB huge pages are unavailable, that function fails
+                * unless HINT flag is indicated
+                */
+               if (!hugepage_16GB_avail) {
+                       mz = rte_memzone_reserve("flag_zone_16G_HINT", size,
+                               SOCKET_ID_ANY,
+                               RTE_MEMZONE_16GB|RTE_MEMZONE_SIZE_HINT_ONLY);
+                       if (mz == NULL) {
+                               printf("MEMZONE FLAG 16GB & HINT\n");
+                               return -1;
+                       }
+                       if (mz->hugepage_sz != RTE_PGSIZE_16M) {
+                               printf("hugepage_sz not equal 16M\n");
+                               return -1;
+                       }
+
+                       mz = rte_memzone_reserve("flag_zone_16G", size,
+                               SOCKET_ID_ANY, RTE_MEMZONE_16GB);
+                       if (mz != NULL) {
+                               printf("MEMZONE FLAG 16GB\n");
+                               return -1;
+                       }
+               }
+       }
+       /*As with 16MB tests above for 16GB huge page requests*/
+       if (hugepage_16GB_avail) {
+               mz = rte_memzone_reserve("flag_zone_16G", size, SOCKET_ID_ANY,
+                               RTE_MEMZONE_16GB);
+               if (mz == NULL) {
+                       printf("MEMZONE FLAG 16GB\n");
+                       return -1;
+               }
+               if (mz->hugepage_sz != RTE_PGSIZE_16G) {
+                       printf("hugepage_sz not equal 16G\n");
+                       return -1;
+               }
+
+               mz = rte_memzone_reserve("flag_zone_16G_HINT", size,
+               SOCKET_ID_ANY, RTE_MEMZONE_16GB|RTE_MEMZONE_SIZE_HINT_ONLY);
+               if (mz == NULL) {
+                       printf("MEMZONE FLAG 16GB\n");
+                       return -1;
+               }
+               if (mz->hugepage_sz != RTE_PGSIZE_16G) {
+                       printf("hugepage_sz not equal 16G\n");
+                       return -1;
+               }
+
+               /* Check if 1GB huge pages are unavailable, that function fails
+                * unless HINT flag is indicated
+                */
+               if (!hugepage_16MB_avail) {
+                       mz = rte_memzone_reserve("flag_zone_16M_HINT", size,
+                               SOCKET_ID_ANY,
+                               RTE_MEMZONE_16MB|RTE_MEMZONE_SIZE_HINT_ONLY);
+                       if (mz == NULL) {
+                               printf("MEMZONE FLAG 16MB & HINT\n");
+                               return -1;
+                       }
+                       if (mz->hugepage_sz != RTE_PGSIZE_16G) {
+                               printf("hugepage_sz not equal 16G\n");
+                               return -1;
+                       }
+                       mz = rte_memzone_reserve("flag_zone_16M", size,
+                               SOCKET_ID_ANY, RTE_MEMZONE_16MB);
+                       if (mz != NULL) {
+                               printf("MEMZONE FLAG 16MB\n");
+                               return -1;
+                       }
+               }
+
+               if (hugepage_16MB_avail && hugepage_16GB_avail) {
+                       mz = rte_memzone_reserve("flag_zone_16M_HINT", size,
+                               SOCKET_ID_ANY,
+                               RTE_MEMZONE_16MB|RTE_MEMZONE_16GB);
+                       if (mz != NULL) {
+                               printf("BOTH SIZES SET\n");
+                               return -1;
+                       }
+               }
+       }
        return 0;
 }
 
@@ -281,9 +402,9 @@ test_memzone_reserve_max(void)
                        continue;
 
                /* align everything */
-               last_addr = RTE_PTR_ALIGN_CEIL(ms[memseg_idx].addr, CACHE_LINE_SIZE);
+               last_addr = RTE_PTR_ALIGN_CEIL(ms[memseg_idx].addr, RTE_CACHE_LINE_SIZE);
                len = ms[memseg_idx].len - RTE_PTR_DIFF(last_addr, ms[memseg_idx].addr);
-               len &= ~((size_t) CACHE_LINE_MASK);
+               len &= ~((size_t) RTE_CACHE_LINE_MASK);
 
                /* cycle through all memzones */
                for (memzone_idx = 0; memzone_idx < RTE_MAX_MEMZONE; memzone_idx++) {
@@ -374,9 +495,9 @@ test_memzone_reserve_max_aligned(void)
                        continue;
 
                /* align everything */
-               last_addr = RTE_PTR_ALIGN_CEIL(ms[memseg_idx].addr, CACHE_LINE_SIZE);
+               last_addr = RTE_PTR_ALIGN_CEIL(ms[memseg_idx].addr, RTE_CACHE_LINE_SIZE);
                len = ms[memseg_idx].len - RTE_PTR_DIFF(last_addr, ms[memseg_idx].addr);
-               len &= ~((size_t) CACHE_LINE_MASK);
+               len &= ~((size_t) RTE_CACHE_LINE_MASK);
 
                /* cycle through all memzones */
                for (memzone_idx = 0; memzone_idx < RTE_MAX_MEMZONE; memzone_idx++) {
@@ -474,11 +595,11 @@ test_memzone_aligned(void)
                printf("Unable to reserve 64-byte aligned memzone!\n");
                return -1;
        }
-       if ((memzone_aligned_32->phys_addr & CACHE_LINE_MASK) != 0)
+       if ((memzone_aligned_32->phys_addr & RTE_CACHE_LINE_MASK) != 0)
                return -1;
-       if (((uintptr_t) memzone_aligned_32->addr & CACHE_LINE_MASK) != 0)
+       if (((uintptr_t) memzone_aligned_32->addr & RTE_CACHE_LINE_MASK) != 0)
                return -1;
-       if ((memzone_aligned_32->len & CACHE_LINE_MASK) != 0)
+       if ((memzone_aligned_32->len & RTE_CACHE_LINE_MASK) != 0)
                return -1;
 
        if (memzone_aligned_128 == NULL) {
@@ -489,7 +610,7 @@ test_memzone_aligned(void)
                return -1;
        if (((uintptr_t) memzone_aligned_128->addr & 127) != 0)
                return -1;
-       if ((memzone_aligned_128->len & CACHE_LINE_MASK) != 0)
+       if ((memzone_aligned_128->len & RTE_CACHE_LINE_MASK) != 0)
                return -1;
 
        if (memzone_aligned_256 == NULL) {
@@ -500,7 +621,7 @@ test_memzone_aligned(void)
                return -1;
        if (((uintptr_t) memzone_aligned_256->addr & 255) != 0)
                return -1;
-       if ((memzone_aligned_256->len & CACHE_LINE_MASK) != 0)
+       if ((memzone_aligned_256->len & RTE_CACHE_LINE_MASK) != 0)
                return -1;
 
        if (memzone_aligned_512 == NULL) {
@@ -511,7 +632,7 @@ test_memzone_aligned(void)
                return -1;
        if (((uintptr_t) memzone_aligned_512->addr & 511) != 0)
                return -1;
-       if ((memzone_aligned_512->len & CACHE_LINE_MASK) != 0)
+       if ((memzone_aligned_512->len & RTE_CACHE_LINE_MASK) != 0)
                return -1;
 
        if (memzone_aligned_1024 == NULL) {
@@ -522,7 +643,7 @@ test_memzone_aligned(void)
                return -1;
        if (((uintptr_t) memzone_aligned_1024->addr & 1023) != 0)
                return -1;
-       if ((memzone_aligned_1024->len & CACHE_LINE_MASK) != 0)
+       if ((memzone_aligned_1024->len & RTE_CACHE_LINE_MASK) != 0)
                return -1;
 
        /* check that zones don't overlap */
@@ -588,8 +709,8 @@ check_memzone_bounded(const char *name, uint32_t len,  uint32_t align,
                return (-1);
        }
 
-       if ((mz->len & CACHE_LINE_MASK) != 0 || mz->len < len ||
-                       mz->len < CACHE_LINE_SIZE) {
+       if ((mz->len & RTE_CACHE_LINE_MASK) != 0 || mz->len < len ||
+                       mz->len < RTE_CACHE_LINE_SIZE) {
                printf("%s(%s): invalid length\n",
                        __func__, mz->name);
                return (-1);
@@ -676,10 +797,9 @@ test_memzone_reserve_memory_in_smallest_segment(void)
 
                        /* set new smallest */
                        min_ms = ms;
-               }
-               else if (prev_min_ms == NULL) {
+               } else if ((prev_min_ms == NULL)
+                       || (prev_min_ms->len > ms->len))
                        prev_min_ms = ms;
-               }
        }
 
        if (min_ms == NULL || prev_min_ms == NULL) {
@@ -691,14 +811,14 @@ test_memzone_reserve_memory_in_smallest_segment(void)
        prev_min_len = prev_min_ms->len;
 
        /* try reserving a memzone in the smallest memseg */
-       mz = rte_memzone_reserve("smallest_mz", CACHE_LINE_SIZE,
+       mz = rte_memzone_reserve("smallest_mz", RTE_CACHE_LINE_SIZE,
                        SOCKET_ID_ANY, 0);
        if (mz == NULL) {
                printf("Failed to reserve memory from smallest memseg!\n");
                return -1;
        }
        if (prev_min_ms->len != prev_min_len &&
-                       min_ms->len != min_len - CACHE_LINE_SIZE) {
+                       min_ms->len != min_len - RTE_CACHE_LINE_SIZE) {
                printf("Reserved memory from wrong memseg!\n");
                return -1;
        }
@@ -737,7 +857,7 @@ test_memzone_reserve_memory_with_smallest_offset(void)
 
        min_ms = NULL;  /*< smallest segment */
        prev_min_ms = NULL; /*< second smallest segment */
-       align = CACHE_LINE_SIZE * 4;
+       align = RTE_CACHE_LINE_SIZE * 4;
 
        /* find two smallest segments */
        for (i = 0; i < RTE_MAX_MEMSEG; i++) {
@@ -756,8 +876,8 @@ test_memzone_reserve_memory_with_smallest_offset(void)
 
                        /* set new smallest */
                        min_ms = ms;
-               }
-               else if (prev_min_ms == NULL) {
+               } else if ((prev_min_ms == NULL)
+                       || (prev_min_ms->len > ms->len)) {
                        prev_min_ms = ms;
                }
        }
@@ -777,7 +897,7 @@ test_memzone_reserve_memory_with_smallest_offset(void)
 
                /* make sure final length is *not* aligned */
                while (((min_ms->addr_64 + len) & (align-1)) == 0)
-                       len += CACHE_LINE_SIZE;
+                       len += RTE_CACHE_LINE_SIZE;
 
                if (rte_memzone_reserve("dummy_mz1", len, SOCKET_ID_ANY, 0) == NULL) {
                        printf("Cannot reserve memory!\n");
@@ -792,12 +912,12 @@ test_memzone_reserve_memory_with_smallest_offset(void)
        }
     /* if we don't need to touch smallest segment but it's aligned */
     else if ((min_ms->addr_64 & (align-1)) == 0) {
-            if (rte_memzone_reserve("align_mz1", CACHE_LINE_SIZE,
+            if (rte_memzone_reserve("align_mz1", RTE_CACHE_LINE_SIZE,
                     SOCKET_ID_ANY, 0) == NULL) {
                             printf("Cannot reserve memory!\n");
                             return -1;
             }
-            if (min_ms->len != min_len - CACHE_LINE_SIZE) {
+            if (min_ms->len != min_len - RTE_CACHE_LINE_SIZE) {
                     printf("Reserved memory from wrong segment!\n");
                     return -1;
             }
@@ -809,7 +929,7 @@ test_memzone_reserve_memory_with_smallest_offset(void)
 
                /* make sure final length is aligned */
                while (((prev_min_ms->addr_64 + len) & (align-1)) != 0)
-                       len += CACHE_LINE_SIZE;
+                       len += RTE_CACHE_LINE_SIZE;
 
                if (rte_memzone_reserve("dummy_mz2", len, SOCKET_ID_ANY, 0) == NULL) {
                        printf("Cannot reserve memory!\n");
@@ -822,7 +942,7 @@ test_memzone_reserve_memory_with_smallest_offset(void)
                        return -1;
                }
        }
-       len = CACHE_LINE_SIZE;
+       len = RTE_CACHE_LINE_SIZE;
 
 
 
@@ -860,7 +980,7 @@ test_memzone_reserve_remainder(void)
        int i, align;
 
        min_len = 0;
-       align = CACHE_LINE_SIZE;
+       align = RTE_CACHE_LINE_SIZE;
 
        config = rte_eal_get_configuration();
 
@@ -878,7 +998,7 @@ test_memzone_reserve_remainder(void)
                        min_ms = ms;
 
                        /* find maximum alignment this segment is able to hold */
-                       align = CACHE_LINE_SIZE;
+                       align = RTE_CACHE_LINE_SIZE;
                        while ((ms->addr_64 & (align-1)) == 0) {
                                align <<= 1;
                        }
@@ -922,7 +1042,7 @@ test_memzone_reserve_remainder(void)
        return 0;
 }
 
-int
+static int
 test_memzone(void)
 {
        const struct rte_memzone *memzone1;
@@ -952,17 +1072,17 @@ test_memzone(void)
        /* check cache-line alignments */
        printf("check alignments and lengths\n");
 
-       if ((memzone1->phys_addr & CACHE_LINE_MASK) != 0)
+       if ((memzone1->phys_addr & RTE_CACHE_LINE_MASK) != 0)
                return -1;
-       if ((memzone2->phys_addr & CACHE_LINE_MASK) != 0)
+       if ((memzone2->phys_addr & RTE_CACHE_LINE_MASK) != 0)
                return -1;
-       if (memzone3 != NULL && (memzone3->phys_addr & CACHE_LINE_MASK) != 0)
+       if (memzone3 != NULL && (memzone3->phys_addr & RTE_CACHE_LINE_MASK) != 0)
                return -1;
-       if ((memzone1->len & CACHE_LINE_MASK) != 0 || memzone1->len == 0)
+       if ((memzone1->len & RTE_CACHE_LINE_MASK) != 0 || memzone1->len == 0)
                return -1;
-       if ((memzone2->len & CACHE_LINE_MASK) != 0 || memzone2->len == 0)
+       if ((memzone2->len & RTE_CACHE_LINE_MASK) != 0 || memzone2->len == 0)
                return -1;
-       if (memzone3 != NULL && ((memzone3->len & CACHE_LINE_MASK) != 0 ||
+       if (memzone3 != NULL && ((memzone3->len & RTE_CACHE_LINE_MASK) != 0 ||
                        memzone3->len == 0))
                return -1;
        if (memzone4->len != 1024)
@@ -1044,3 +1164,9 @@ test_memzone(void)
 
        return 0;
 }
+
+static struct test_command memzone_cmd = {
+       .command = "memzone_autotest",
+       .callback = test_memzone,
+};
+REGISTER_TEST_COMMAND(memzone_cmd);