Lines Matching defs:class
139 * determined). NOTE: all those class sizes must be set as multiple of
188 * Size of objects stored in this class. Must be multiple
248 unsigned int class:CLASS_BITS + 1;
486 *class_idx = zspage->class;
492 return pool->size_class[zspage->class];
499 zspage->class = class_idx;
505 * class maintains a list of zspages where each zspage is divided
508 * size class which has chunk size big enough to hold the given size.
521 static inline void class_stat_inc(struct size_class *class,
524 class->stats.objs[type] += cnt;
527 static inline void class_stat_dec(struct size_class *class,
530 class->stats.objs[type] -= cnt;
533 static inline unsigned long zs_stat_get(struct size_class *class, int type)
535 return class->stats.objs[type];
555 static unsigned long zs_can_compact(struct size_class *class);
561 struct size_class *class;
569 "class", "size", "10%", "20%", "30%", "40%",
576 class = pool->size_class[i];
578 if (class->index != i)
583 seq_printf(s, " %5u %5u ", i, class->size);
585 inuse_totals[fg] += zs_stat_get(class, fg);
586 seq_printf(s, "%9lu ", zs_stat_get(class, fg));
589 obj_allocated = zs_stat_get(class, ZS_OBJS_ALLOCATED);
590 obj_used = zs_stat_get(class, ZS_OBJS_INUSE);
591 freeable = zs_can_compact(class);
594 objs_per_zspage = class->objs_per_zspage;
596 class->pages_per_zspage;
600 class->pages_per_zspage, freeable);
660 * For each size class, zspages are divided into different groups
664 static int get_fullness_group(struct size_class *class, struct zspage *zspage)
669 objs_per_zspage = class->objs_per_zspage;
686 * Each size class maintains various freelists and zspages are assigned
689 * identified by <class, fullness_group>.
691 static void insert_zspage(struct size_class *class,
695 class_stat_inc(class, fullness, 1);
696 list_add(&zspage->list, &class->fullness_list[fullness]);
701 * by <class, fullness_group>.
703 static void remove_zspage(struct size_class *class,
707 VM_BUG_ON(list_empty(&class->fullness_list[fullness]));
710 class_stat_dec(class, fullness, 1);
714 * Each size class maintains zspages in different fullness groups depending
722 static int fix_fullness_group(struct size_class *class, struct zspage *zspage)
728 newfg = get_fullness_group(class, zspage);
732 remove_zspage(class, zspage, currfg);
733 insert_zspage(class, zspage, newfg);
848 static void __free_zspage(struct zs_pool *pool, struct size_class *class,
875 class_stat_dec(class, ZS_OBJS_ALLOCATED, class->objs_per_zspage);
876 atomic_long_sub(class->pages_per_zspage, &pool->pages_allocated);
879 static void free_zspage(struct zs_pool *pool, struct size_class *class,
895 remove_zspage(class, zspage, ZS_INUSE_RATIO_0);
896 __free_zspage(pool, class, zspage);
900 static void init_zspage(struct size_class *class, struct zspage *zspage)
916 while ((off += class->size) < PAGE_SIZE) {
918 link += class->size / sizeof(*link);
944 static void create_page_chain(struct size_class *class, struct zspage *zspage,
950 int nr_pages = class->pages_per_zspage;
967 if (unlikely(class->objs_per_zspage == 1 &&
968 class->pages_per_zspage == 1))
978 * Allocate a zspage for the given size class
981 struct size_class *class,
994 for (i = 0; i < class->pages_per_zspage; i++) {
1011 create_page_chain(class, zspage, pages);
1012 init_zspage(class, zspage);
1018 static struct zspage *find_get_zspage(struct size_class *class)
1024 zspage = list_first_entry_or_null(&class->fullness_list[i],
1140 static bool zspage_full(struct size_class *class, struct zspage *zspage)
1142 return get_zspage_inuse(zspage) == class->objs_per_zspage;
1163 struct size_class *class;
1165 class = pool->size_class[get_size_class_index(size)];
1167 return class->index;
1200 struct size_class *class;
1221 * zs_unmap_object API so delegate the locking from class to zspage
1227 class = zspage_class(pool, zspage);
1228 off = offset_in_page(class->size * obj_idx);
1233 if (off + class->size <= PAGE_SIZE) {
1245 ret = __zs_map_object(area, pages, off, class->size);
1261 struct size_class *class;
1267 class = zspage_class(pool, zspage);
1268 off = offset_in_page(class->size * obj_idx);
1271 if (off + class->size <= PAGE_SIZE)
1280 __zs_unmap_object(area, pages, off, class->size);
1293 * The function returns the size of the first huge class - any object of equal
1313 struct size_class *class;
1319 class = pool->size_class[zspage->class];
1323 offset = obj * class->size;
1363 struct size_class *class;
1376 class = pool->size_class[get_size_class_index(size)];
1380 zspage = find_get_zspage(class);
1384 fix_fullness_group(class, zspage);
1386 class_stat_inc(class, ZS_OBJS_INUSE, 1);
1393 zspage = alloc_zspage(pool, class, gfp);
1401 newfg = get_fullness_group(class, zspage);
1402 insert_zspage(class, zspage, newfg);
1403 set_zspage_mapping(zspage, class->index, newfg);
1405 atomic_long_add(class->pages_per_zspage, &pool->pages_allocated);
1406 class_stat_inc(class, ZS_OBJS_ALLOCATED, class->objs_per_zspage);
1407 class_stat_inc(class, ZS_OBJS_INUSE, 1);
1450 struct size_class *class;
1464 class = zspage_class(pool, zspage);
1466 class_stat_dec(class, ZS_OBJS_INUSE, 1);
1467 obj_free(class->size, obj);
1469 fullness = fix_fullness_group(class, zspage);
1471 free_zspage(pool, class, zspage);
1478 static void zs_object_copy(struct size_class *class, unsigned long dst,
1488 s_size = d_size = class->size;
1493 s_off = offset_in_page(class->size * s_objidx);
1494 d_off = offset_in_page(class->size * d_objidx);
1496 if (s_off + class->size > PAGE_SIZE)
1499 if (d_off + class->size > PAGE_SIZE)
1510 if (written == class->size)
1531 s_size = class->size - written;
1539 d_size = class->size - written;
1552 static unsigned long find_alloced_obj(struct size_class *class,
1561 offset += class->size * index;
1567 offset += class->size;
1585 struct size_class *class = pool->size_class[src_zspage->class];
1588 handle = find_alloced_obj(class, s_page, &obj_idx);
1599 zs_object_copy(class, free_obj, used_obj);
1602 obj_free(class->size, used_obj);
1605 if (zspage_full(class, dst_zspage))
1614 static struct zspage *isolate_src_zspage(struct size_class *class)
1620 zspage = list_first_entry_or_null(&class->fullness_list[fg],
1623 remove_zspage(class, zspage, fg);
1631 static struct zspage *isolate_dst_zspage(struct size_class *class)
1637 zspage = list_first_entry_or_null(&class->fullness_list[fg],
1640 remove_zspage(class, zspage, fg);
1649 * putback_zspage - add @zspage into right class's fullness list
1650 * @class: destination class
1655 static int putback_zspage(struct size_class *class, struct zspage *zspage)
1659 fullness = get_fullness_group(class, zspage);
1660 insert_zspage(class, zspage, fullness);
1661 set_zspage_mapping(zspage, class->index, fullness);
1755 static void replace_sub_page(struct size_class *class, struct zspage *zspage,
1771 create_page_chain(class, zspage, pages);
1802 struct size_class *class;
1830 class = zspage_class(pool, zspage);
1846 addr += class->size) {
1858 replace_sub_page(class, zspage, newpage, page);
1906 struct size_class *class;
1915 class = pool->size_class[i];
1916 if (class->index != i)
1920 list_splice_init(&class->fullness_list[ZS_INUSE_RATIO_0],
1931 class = pool->size_class[class_idx];
1933 __free_zspage(pool, class, zspage);
1972 static unsigned long zs_can_compact(struct size_class *class)
1975 unsigned long obj_allocated = zs_stat_get(class, ZS_OBJS_ALLOCATED);
1976 unsigned long obj_used = zs_stat_get(class, ZS_OBJS_INUSE);
1982 obj_wasted /= class->objs_per_zspage;
1984 return obj_wasted * class->pages_per_zspage;
1988 struct size_class *class)
1999 while (zs_can_compact(class)) {
2003 dst_zspage = isolate_dst_zspage(class);
2009 src_zspage = isolate_src_zspage(class);
2016 fg = putback_zspage(class, src_zspage);
2020 free_zspage(pool, class, src_zspage);
2021 pages_freed += class->pages_per_zspage;
2025 if (get_fullness_group(class, dst_zspage) == ZS_INUSE_RATIO_100
2027 putback_zspage(class, dst_zspage);
2038 putback_zspage(class, src_zspage);
2043 putback_zspage(class, dst_zspage);
2054 struct size_class *class;
2067 class = pool->size_class[i];
2068 if (class->index != i)
2070 pages_freed += __zs_compact(pool, class);
2106 struct size_class *class;
2112 class = pool->size_class[i];
2113 if (class->index != i)
2116 pages_to_free += zs_can_compact(class);
2198 struct size_class *class;
2210 * class. Any object bigger than or equal to that will
2211 * endup in the huge class.
2220 * size class search - so object may be smaller than
2221 * huge class size, yet it still can end up in the huge
2222 * class because it grows by ZS_HANDLE_SIZE extra bytes
2223 * right before class lookup.
2244 class = kzalloc(sizeof(struct size_class), GFP_KERNEL);
2245 if (!class)
2248 class->size = size;
2249 class->index = i;
2250 class->pages_per_zspage = pages_per_zspage;
2251 class->objs_per_zspage = objs_per_zspage;
2252 pool->size_class[i] = class;
2256 INIT_LIST_HEAD(&class->fullness_list[fullness]);
2260 prev_class = class;
2292 struct size_class *class = pool->size_class[i];
2294 if (!class)
2297 if (class->index != i)
2301 if (list_empty(&class->fullness_list[fg]))
2305 class->size, fg);
2307 kfree(class);