/** * * KAIR - Library for Kernel perspective AI based Resource Control * * COPYRIGHT(C) Samsung Electronics Co., Ltd. All Right Reserved. * * Implementation of ECAVE - Elastic Capacity Vessel - theory to abstract of * arbitrary systems whose capacity is self regulated by purely observing the * behavior of object coming from outside of the system. * **/ #include #include #include #include #include #include "d2u_decl_cmtpdf.h" #define __INFTY (0xEFEFEFEF) #define POSITIVE_STRETCH (0x80000000) #define NEGATIVE_STRETCH (0x40000000) #define STRETCH_MASK (0xC0000000) #define HARMONIC_MASK (0x3FFFFFFF) #define ONE2TWO_RES (64) #define LOG_UPSCALE (512) #define LOG_UPSCALE_SHIFT (9) #define ASYMMETRIC_INFERENCE const unsigned int __lb2[ONE2TWO_RES] = { 11, 22, 33, 44, 54, 65, 75, 85, 95, 105, 115, 125, 134, 144, 153, 162, 171, 180, 189, 198, 206, 215, 223, 232, 240, 248, 256, 264, 272, 280, 288, 295, 303, 310, 318, 325, 332, 340, 347, 354, 361, 368, 375, 381, 388, 395, 401, 408, 414, 421, 427, 434, 440, 446, 452, 459, 465, 471, 477, 483, 488, 494, 500, 506}; typedef enum { KLD_LPLANE, KLD_RPLANE, } kld_plane; /*............................................................................. *............................................................................. *............. """ sysfs interfaces with an Kair instance """" .............. *............................................................................. *...........................................................................*/ /** * HTML skeletons for building Kair PDF description template **/ const char __hcmp_head[] = "Kair TPDF description"; const char __hcmp_entr[] = ""; const char __hcmp_foot[] = "

level "; const char __hcmp_flr1[] = " TPDF shape


- randomness : "; const char __hcmp_flr2[] = "

- observation interval : "; const char __hcmp_flr3[] = "

- weight : "; const char __hcmp_iter[] = "

"; const char __hcmp_clsr[] = "

\n"; /** * @abst_kobj : /abstract entry direcly placed beneath /sys. **/ struct kobject *abst_kobj; /** * KAIR instance can be dynamically created by anonymous clients. * SYSFS interface to the particular instance will be handled through an * exclusive form of kset in sysfs /sys/abst/kair, which means /kair is * defined as a primitive abstraction node. **/ static struct kset *krinst_set; static unsigned int kair_cap_soft_bettor(struct kair_class *self, struct rand_var *v, unsigned int cap_legacy); static unsigned int kair_cap_strict_bettor(struct kair_class *self, struct rand_var *v, unsigned int cap_legacy); static ssize_t krinst_attr_show(struct kobject *kobj, struct attribute *attr, char *buf) { struct krinst_attribute *attribute = to_krinst_attr(attr); struct krinst_obj *node = to_krinst_obj(kobj); if (!attribute->show) return -EIO; return attribute->show(node, attribute, buf); } static ssize_t krinst_attr_store(struct kobject *kobj, struct attribute *attr, const char *buf, size_t len) { struct krinst_attribute *attribute = to_krinst_attr(attr); struct krinst_obj *node = to_krinst_obj(kobj); if (!attribute->store) return -EIO; return attribute->store(node, attribute, buf, len); } static const struct sysfs_ops krinst_sysfs_ops = { .show = krinst_attr_show, .store = krinst_attr_store, }; static void krinst_release(struct kobject *kobj) { struct krinst_obj *node = to_krinst_obj(kobj); kfree(node); } static ssize_t choke_cnt_show(struct krinst_obj *node, struct krinst_attribute *attr, char *buf) { if (node->inst) return sprintf(buf, "%d\n", node->inst->stats.choke_cnt); else return sprintf(buf, "dangled reference\n"); } KRINST_ATTR_RO(choke_cnt); static ssize_t save_total_show(struct krinst_obj *node, struct krinst_attribute *attr, char *buf) { if (node->inst) return sprintf(buf, "%lld\n", node->inst->stats.save_total); else return sprintf(buf, "dangled reference\n"); } KRINST_ATTR_RO(save_total); static ssize_t epsilon_show(struct krinst_obj *node, struct krinst_attribute *attr, char *buf) { if (node->inst) return sprintf(buf, "%d\n", node->inst->epsilon); else return sprintf(buf, "dangled reference\n"); } static ssize_t epsilon_store(struct krinst_obj *node, struct krinst_attribute *attr, const char *buf, size_t count) { int retval = 0; if (node->inst) { retval = kstrtouint(buf, 10, &node->inst->epsilon); if (retval < 0) return retval; } else return -EFAULT; return count; } KRINST_ATTR_RW(epsilon); static ssize_t resilience_show(struct krinst_obj *node, struct krinst_attribute *attr, char *buf) { if (node->inst) return sprintf(buf, "%d\n", node->inst->resilience); else return sprintf(buf, "dangled reference\n"); } KRINST_ATTR_RO(resilience); static ssize_t rand_neutral_show(struct krinst_obj *node, struct krinst_attribute *attr, char *buf) { if (node->inst) return sprintf(buf, "%d\n", node->inst->stats.rand_neutral); else return sprintf(buf, "dangled reference\n"); } static ssize_t rand_neutral_store(struct krinst_obj *node, struct krinst_attribute *attr, const char *buf, size_t count) { int retval = 0; if (node->inst) { retval = kstrtouint(buf, 10, &node->inst->stats.rand_neutral); if (retval < 0) return retval; } else return -EFAULT; return count; } KRINST_ATTR_RW(rand_neutral); static ssize_t throttling_show(struct krinst_obj *node, struct krinst_attribute *attr, char *buf) { if (node->inst) return sprintf(buf, "%d\n", node->inst->stats.throttling); else return sprintf(buf, "dangled reference\n"); } KRINST_ATTR_RO(throttling); static ssize_t bettor_select_show(struct krinst_obj *node, struct krinst_attribute *attr, char *buf) { if (node->inst) { if (node->inst->cap_bettor == kair_cap_soft_bettor) return sprintf(buf, "soft\n"); else return sprintf(buf, "strict\n"); } else return sprintf(buf, "dangled reference\n"); } static ssize_t bettor_select_store(struct krinst_obj *node, struct krinst_attribute *attr, const char *buf, size_t count) { if (node->inst) { if (!strncmp(buf, "soft", 4)) node->inst->cap_bettor = kair_cap_soft_bettor; else if (!strncmp(buf, "strict", 6)) node->inst->cap_bettor = kair_cap_strict_bettor; } else return -EFAULT; return count; } KRINST_ATTR_RW(bettor_select); static ssize_t tpdf_cascade_show(struct krinst_obj *node, struct krinst_attribute *attr, char *buf) { char *btemp = NULL; char *ptemp = NULL; struct tpdf *level; unsigned int inc, run; struct list_head *head; if (node->inst) { /** * Allocating memory for HTML template **/ btemp = kzalloc(PAGE_SIZE, GFP_KERNEL); if (!btemp) return -1; else ptemp = btemp; ptemp += sprintf(ptemp, "%s", __hcmp_head); head = &node->inst->tpdf_cascade; for (level = list_first_entry(head, struct tpdf, pos), inc = 1; &level->pos != head; level = list_next_entry(level, pos), inc++) { ptemp += sprintf(ptemp, "%s", __hcmp_entr); ptemp += sprintf(ptemp, "%d", inc); ptemp += sprintf(ptemp, "%s", __hcmp_flr1); ptemp += sprintf(ptemp, "%d", level->irand); ptemp += sprintf(ptemp, "%s", __hcmp_flr2); ptemp += sprintf(ptemp, "%lld", kair_window_size(level)); ptemp += sprintf(ptemp, "%s", __hcmp_flr3); ptemp += sprintf(ptemp, "x%d", level->weight); ptemp += sprintf(ptemp, "%s", __hcmp_iter); for (run = 0; run < level->qlvl; run++) { ptemp += sprintf(ptemp, "%d", level->qtbl[run]); ptemp += sprintf(ptemp, "%s", __hcmp_iter); } ptemp += sprintf(ptemp, "%s", __hcmp_clsr); } ptemp += sprintf(ptemp, "%s", __hcmp_foot); memcpy(buf, btemp, PAGE_SIZE); kfree(btemp); } return (ssize_t)(ptemp - btemp); } KRINST_ATTR_RO(tpdf_cascade); static struct attribute *krinst_default_attrs[] = { &choke_cnt_attr.attr, &save_total_attr.attr, &epsilon_attr.attr, &resilience_attr.attr, &rand_neutral_attr.attr, &throttling_attr.attr, &bettor_select_attr.attr, &tpdf_cascade_attr.attr, NULL, }; /** * KAIR exclusive ktype for our kobjects **/ static struct kobj_type krinst_ktype = { .sysfs_ops = &krinst_sysfs_ops, .release = krinst_release, .default_attrs = krinst_default_attrs, }; static struct krinst_obj *create_krinst_obj(struct kair_class *src) { struct krinst_obj *node; int retval; node = kzalloc(sizeof(*node), GFP_KERNEL); if (!node) return NULL; /* Linking @ parent kset /sys/kair */ node->obj.kset = krinst_set; node->inst = src; retval = kobject_init_and_add(&node->obj, &krinst_ktype, &krinst_set->kobj, "%s", (const char *)src->alias); if (retval) { kobject_put(&node->obj); return NULL; } /* Sending the uevent that the kobject was added to the system */ kobject_uevent(&node->obj, KOBJ_ADD); return node; } static void destroy_krinst_obj(struct krinst_obj *node) { node->inst = NULL; kobject_del(&node->obj); kobject_put(&node->obj); } static int __init kair_prepare(void) { abst_kobj = kobject_create_and_add("abst", NULL); if (!abst_kobj) goto s1_error; krinst_set = kset_create_and_add("kair", NULL, abst_kobj); if (!krinst_set) goto s2_error; return 0; s2_error: kobject_put(abst_kobj); s1_error: return -ENOMEM; } postcore_initcall(kair_prepare); static void __exit kair_clean(void) { kset_unregister(krinst_set); kobject_put(abst_kobj); } __exitcall(kair_clean); /*............................................................................. *............................................................................. *... """ KAIR-wise Temporal Probability Density Function Manipulators """ .... *............................................................................. *...........................................................................*/ /** * """ KAIR TPDF cascading method """ **/ void kair_tpdf_cascading(struct kair_class *vessel, struct tpdf *element) { list_add(&element->pos, &vessel->tpdf_cascade); } EXPORT_SYMBOL(kair_tpdf_cascading); /** * """ KAIR TPDF cleaning method """ **/ void kair_tpdf_cleaning(struct kair_class *vessel) { struct tpdf *cur, *tmp; if (!list_empty(&vessel->tpdf_cascade)) { list_for_each_entry_safe(cur, tmp, &vessel->tpdf_cascade, pos) { list_del(&cur->pos); cur->untabling(cur); cur->rv_unregister(cur); kfree(cur); } } } EXPORT_SYMBOL(kair_tpdf_cleaning); /** * """ KAIR default API to build 3-level TPDF cascading """ **/ int kair_build_tpdf_cascade(struct kair_class *vessel) { unsigned int weight_sum; #if KAIR_TPDF_CASCADE_LEVEL > 1 struct tpdf *tpdf_inf, *tpdf_fin, *tpdf_ins; tpdf_inf = kmalloc(sizeof(struct tpdf), GFP_KERNEL); if (!tpdf_inf) goto l3_nomem; tpdf_fin = kmalloc(sizeof(struct tpdf), GFP_KERNEL); if (!tpdf_fin) goto l2_nomem; tpdf_ins = kmalloc(sizeof(struct tpdf), GFP_KERNEL); if (!tpdf_ins) goto l1_nomem; kair_l3_pdf_init(tpdf_inf); kair_l2_pdf_init(tpdf_fin); kair_l1_pdf_init(tpdf_ins); kair_tpdf_cascading(vessel, tpdf_inf); kair_tpdf_cascading(vessel, tpdf_fin); kair_tpdf_cascading(vessel, tpdf_ins); weight_sum = tpdf_inf->weight + tpdf_fin->weight + tpdf_ins->weight; goto exit; l1_nomem: kfree(tpdf_fin); l2_nomem: kfree(tpdf_inf); l3_nomem: return -ENOMEM; exit: #else struct tpdf *tpdf_ins; tpdf_ins = kmalloc(sizeof(struct tpdf), GFP_KERNEL); if (!tpdf_ins) return -ENOMEM; kair_l1_pdf_init(tpdf_ins); kair_tpdf_cascading(vessel, tpdf_ins); weight_sum = tpdf_ins->weight; #endif vessel->capa_denom = ilog2(weight_sum + 1); return 0; } EXPORT_SYMBOL(kair_build_tpdf_cascade); /** * """ KAIR TPDF availability checker """ **/ static inline bool is_tpdf_prepared(struct tpdf *self) { bool ret; if (is_kair_window_infty(self)) ret = (kair_windowing_cnt(self) >= KAIR_TPDF_CUMSUM) ? true : false; else ret = (kair_windowing_cnt(self) >= kair_window_size(self)) ? true : false; return ret; } /** * """ KAIR default TPDF total equilibrator """ **/ void kair_tpdf_equilibrator(struct tpdf *self) { unsigned int cursor; self->pc_cnt++; if (self->pc_cnt == KAIR_TPDF_CUMSUM) { for (cursor = 0; cursor < self->qlvl; cursor++) self->qtbl[cursor] >>= 1; self->pc_cnt = 0; } } EXPORT_SYMBOL(kair_tpdf_equilibrator); /** * """ KAIR default TPDF rescaler """ * The rescaling ratio is calculated 'kair_TPDF_CUMSUM / kair_window_size()' **/ void kair_tpdf_rescaler(struct tpdf *self) { unsigned int cursor; unsigned int denom = (unsigned int)kair_window_size(self); if (kair_window_need_rescale(self)) { for (cursor = 0; cursor < self->qlvl; cursor++) self->qtbl[cursor] = mult_frac(self->qtbl[cursor], KAIR_TPDF_CUMSUM, denom); kair_window_rescale_done(self); } } EXPORT_SYMBOL(kair_tpdf_rescaler); /** * """ KAIR default TPDF tabling procedure """ * Which is mainly composed of; * - memory allocation * - copying the existing TPDF image from storage to runtime memory * - address mapping to self **/ int kair_tpdf_tabling(struct tpdf *self) { self->qtbl = kzalloc(sizeof(int) * self->qlvl, GFP_KERNEL); if (!self->qtbl) return -ENOMEM; if (!is_kair_window_infty(self)) { if (tfifo_alloc(&self->cache, kair_window_size(self)) == false) return -ENOMEM; } return 0; } EXPORT_SYMBOL(kair_tpdf_tabling); /** * """ KAIR default TPDF untabling procedure """ * Which is mainly composed of; * - memory free * - store the built TPDF image to storage * - address unmapping **/ void kair_tpdf_untabling(struct tpdf *self) { kfree(self->qtbl); tfifo_free(&self->cache); } EXPORT_SYMBOL(kair_tpdf_untabling); void kair_tpdf_rv_register(struct tpdf *self, struct rand_var *rv) { self->rv = rv; } EXPORT_SYMBOL(kair_tpdf_rv_register); void kair_tpdf_rv_unregister(struct tpdf *self) { self->rv = NULL; } EXPORT_SYMBOL(kair_tpdf_rv_unregister); /*............................................................................. *............................................................................. *.................. """ Generic Mathematical Functions """ ................... *............................................................................. *...........................................................................*/ /** * """ Caculating Kullback-Liebler diversity """ * Evaluating how much two random variables are similar. this is actually done * by taking full integral on the relative entropy. * @comparer : TPDF structure quantized by its own qlvl. * @comparee : comparee's raw integer TPDF table quantized by comparer's qlvl. **/ int kl_diversity(struct tpdf *comparer, unsigned int *comparee) { int kl_div = 0; unsigned int idx; unsigned int p, q, pbase, qbase, entp, entq; int log2p, log2q; for (idx = 0; idx < comparer->qlvl; idx++) { p = comparer->qtbl[idx]; q = comparee[idx]; /* Q(i)=0 implies P(i)=0 */ if (p == 0 || q == 0) continue; log2p = ilog2(p); log2q = ilog2(q); pbase = 1 << log2p; qbase = 1 << log2q; entp = (p == pbase) ? (p * log2p) : ((p * log2p) + ((p * __lb2[mult_frac(p - pbase, ONE2TWO_RES, pbase)]) >> LOG_UPSCALE_SHIFT)); entq = (q == qbase) ? (p * log2q) : ((p * log2q) + ((p * __lb2[mult_frac(q - qbase, ONE2TWO_RES, qbase)]) >> LOG_UPSCALE_SHIFT)); /** * If the probability of comparer random variable at a scope is * bigger than the one's of comparee, KL diversity will be increased * as far as the relative entropy caculated differs, otherwise, * KL diversity will be fairly decreased. **/ kl_div += (entp - entq); } return kl_div; } EXPORT_SYMBOL(kl_diversity); /** * """ Caculating Asymmetric Kullback-Liebler diversity """ * Evaluating how much two random variables are similar. this is actually done * by taking full integral on the relative entropy. * @comparer : TPDF structure quantized by its own qlvl. * @comparee : comparee's raw integer TPDF table quantized by comparer's qlvl. **/ int kl_asymm_diversity(struct tpdf *comparer, unsigned int *comparee, kld_plane side) { int kl_div = 0; unsigned int idx; unsigned int mean = comparer->qlvl >> 1; unsigned int head = (side == KLD_LPLANE) ? 0 : mean; unsigned int foot = (side == KLD_LPLANE) ? mean : comparer->qlvl - 1; unsigned int p, q, pbase, qbase, entp, entq; int log2p, log2q; for (idx = head; idx <= foot; idx++) { p = comparer->qtbl[idx]; q = comparee[idx]; /* Q(i)=0 implies P(i)=0 */ if (p == 0 || q == 0) continue; log2p = ilog2(p); log2q = ilog2(q); pbase = 1 << log2p; qbase = 1 << log2q; entp = (p == pbase) ? (p * log2p) : ((p * log2p) + ((p * __lb2[mult_frac(p - pbase, ONE2TWO_RES, pbase)]) >> LOG_UPSCALE_SHIFT)); entq = (q == qbase) ? (p * log2q) : ((p * log2q) + ((p * __lb2[mult_frac(q - qbase, ONE2TWO_RES, qbase)]) >> LOG_UPSCALE_SHIFT)); /** * If the probability of comparer random variable at a scope is * bigger than the one's of comparee, KL diversity will be increased * as far as the relative entropy caculated differs, otherwise, * KL diversity will be fairly decreased. **/ kl_div += (entp - entq); } return kl_div; } EXPORT_SYMBOL(kl_asymm_diversity); /** * """ Default linear interpolator """ * Returning interpolated value; * @self : temporal probability density function * @top_pos : top position * @raw_pos : raw position **/ unsigned int linear_interpolator(struct tpdf *self, unsigned int top_pos, unsigned int raw_pos) { unsigned int psec = top_pos >> ilog2(self->qlvl); unsigned int lpos = raw_pos >> psec; unsigned int lval = self->qtbl[lpos]; unsigned int rval = self->qtbl[lpos + 1]; unsigned int delta = raw_pos - (lpos << psec); return (delta * lval + (top_pos - delta) * rval) >> psec; } EXPORT_SYMBOL(linear_interpolator); /*............................................................................. *............................................................................. *................... """ KAIR capsulated functions """ ...................... *............................................................................. *...........................................................................*/ /** * Under assuming the function kl-diversity to given TPDF-TPDF comparison is * quite noisy-convex, an alternative greedy gradient decsending algorithm * is exhibited here. * @targ : * @mold : **/ static inline randomness __gs_on_kld(struct tpdf *targ, unsigned int **mold, unsigned int max_var) { int cur; int min_idx = 0; int min_kld = __INFTY; int lmost = 0; int rmost = (int)max_var - 1; int width = (int)max_var; int hop_total = ilog2((unsigned int)width); int hop_width = (1 << hop_total) / hop_total; int kld_ref[16]; memset(kld_ref, 0xEF, sizeof(kld_ref)); /** * Complexity : O(N x log N * log(log N) x ...) **/ do { for (cur = lmost; cur <= (rmost + 1); cur += hop_width) { cur = cur > rmost ? rmost : cur; #ifndef ASYMMETRIC_INFERENCE if (kld_ref[cur] == __INFTY) kld_ref[cur] = kl_diversity(targ, (unsigned int *)mold + cur * KAIR_QUANT_STEP); if (abs(kld_ref[cur]) < abs(min_kld)) { min_kld = kld_ref[cur]; min_idx = cur; } #else if (kld_ref[cur] == __INFTY) { kld_ref[cur] = kl_asymm_diversity(targ, (unsigned int *)mold + cur * KAIR_QUANT_STEP, KLD_RPLANE); } if (abs(kld_ref[cur]) < abs(min_kld)) { min_kld = kld_ref[cur]; min_idx = cur; } #endif } lmost = max(min_idx - hop_width + 1, lmost); rmost = min(min_idx + hop_width - 1, rmost); width = rmost - lmost + 1; hop_total = ilog2((unsigned int)width); hop_width = (1 << hop_total) / hop_total; } while (rmost - lmost > 2); return (randomness)min_idx; } /** * """ KAIR default searcher of the template TPDF """ * Nearest resembling to given **/ static int kair_search_nearest_job_tpdf(struct kair_class *self) { struct tpdf *level; if (list_empty(&self->tpdf_cascade)) return KAIR_DIVERGING; list_for_each_entry(level, &self->tpdf_cascade, pos) { if (!is_tpdf_prepared(level)) continue; if (level->pc_cnt) continue; level->irand = __gs_on_kld(level, (unsigned int **)d2u_decl_cmtpdf, self->resilience); } level = list_first_entry(&self->tpdf_cascade, struct tpdf, pos); return level->irand; } /** * **/ static inline void kair_tpdf_carving_out(struct tpdf *self) { unsigned int scope; unsigned int mult = kair_window_size(self) / KAIR_TPDF_CUMSUM; self->rescaler(self); self->pc_cnt++; scope = tfifo_out(&self->cache); self->qtbl[scope] = self->qtbl[scope] ? self->qtbl[scope] - 1 : 0; if (self->pc_cnt == kair_window_size(self) / mult) self->pc_cnt = 0; } /** * """ KAIR job probability collapse operator """ * Which takes place of generative learning what temporal probability density * function of given job intensity looks like. **/ static void kair_job_probability_collapse(struct kair_class *self, struct rand_var *v) { struct tpdf *level; unsigned int scope; bool in_choke = (v->nval == v->ubound); if (list_empty(&self->tpdf_cascade)) return; if (in_choke) { self->stats.choke_cnt++; } else { list_for_each_entry(level, &self->tpdf_cascade, pos) { scope = (unsigned int)RV_TAILORED(level, v); level->qtbl[scope]++; if (is_kair_window_infty(level)) { if (kair_windowing_cnt(level) >= KAIR_TPDF_CUMSUM) level->equilibrator(level); else level->win_size++; } else { tfifo_in(&level->cache, scope); if (kair_windowing_cnt(level) >= kair_window_size(level)) kair_tpdf_carving_out(level); else level->win_size++; } } } } /** * taking integral on Sunchul PDF from given i to maximum **/ static inline unsigned int __integral_schi2m(randomness r, unsigned int i) { unsigned int total = 0; unsigned int x; for (x = i; x < KAIR_QUANT_STEP; x++) total += d2u_decl_cmtpdf[(unsigned int)r][x]; return total; } /** * """ KAIR default desirable capacity bettor """ * Betting reasonable kair capacity per job intensity induced outside by * stochastic processing of job intensity's centered-mean TPDF. * @self * @v * @cap_legacy : **/ static unsigned int kair_cap_soft_bettor(struct kair_class *self, struct rand_var *v, unsigned int cap_legacy) { struct tpdf *level; unsigned int min_cap = mult_frac(cap_legacy, self->kairistic.theta_numer, self->kairistic.theta_denom); unsigned int max_cap = mult_frac(cap_legacy, self->kairistic.gamma_numer, self->kairistic.gamma_denom); unsigned int new_cap = 0; if (list_empty(&self->tpdf_cascade)) return cap_legacy; if (cap_legacy == 0) return 0; list_for_each_entry(level, &self->tpdf_cascade, pos) { if (level->irand == KAIR_DIVERGING) { new_cap = cap_legacy; } else { new_cap += level->weight * ((level->irand > self->stats.rand_neutral) ? max_cap >> self->capa_denom : min_cap >> self->capa_denom); } } self->stats.save_total += ((long long)cap_legacy - (long long)new_cap) / 10; return new_cap; } static unsigned int kair_cap_strict_bettor(struct kair_class *self, struct rand_var *v, unsigned int cap_legacy) { struct tpdf *level; unsigned int new_cap = mult_frac(cap_legacy, self->kairistic.theta_numer, self->kairistic.theta_denom); unsigned int max_cap = mult_frac(cap_legacy, self->kairistic.gamma_numer, self->kairistic.gamma_denom); unsigned int skew; unsigned int run_hmny; unsigned int cap_unit = (max_cap - new_cap) >> self->capa_denom; s32 cap_delta = 0; if (list_empty(&self->tpdf_cascade)) return cap_legacy; if (cap_legacy == 0) return 0; list_for_each_entry(level, &self->tpdf_cascade, pos) { unsigned int scope = RV_TAILORED(level, v); unsigned int min_hmny = __INFTY; unsigned int opt_skew = __INFTY; if (level->irand == KAIR_DIVERGING) continue; for (skew = 0; skew < self->resilience; skew++) { unsigned int __cap = cap_legacy + cap_unit * (level->irand - skew); run_hmny = self->epsilon * __integral_schi2m(skew, scope) + __cap; if (min_hmny > run_hmny) { min_hmny = run_hmny; opt_skew = skew; } } cap_delta = cap_unit * (level->irand - opt_skew); new_cap += cap_delta * level->weight; } self->stats.save_total += ((long long)cap_legacy - (long long)new_cap) / 10; return new_cap; } /** * """ KAIR default instance initializer """ * Making stuffs inside of kair instance ready. for now, preparing * the multi-leveled TPDF cascade. * @self : instance itself **/ static int kair_initializer(struct kair_class *self) { int retval = 0; retval = kair_build_tpdf_cascade(self); if (retval < 0) return retval; self->extif = create_krinst_obj(self); if (!self->extif) return -ENOMEM; return retval; } /** * """ KAIR default instance stopper """ * A part of suspend sequence. Reset TPDF as well. * @self : instance itself **/ static void kair_stopper(struct kair_class *self) { struct tpdf *cur; if (!list_empty(&self->tpdf_cascade)) { list_for_each_entry(cur, &self->tpdf_cascade, pos) { if (!is_kair_window_infty(cur)) { memset(cur->qtbl, 0, sizeof(int) * cur->qlvl); tfifo_free(&cur->cache); tfifo_alloc(&cur->cache, kair_window_size(cur)); cur->pc_cnt = 0; } } } } /** * """ KAIR default instance finalizer """ * Making the kair instance ready for the removal. for now, releasing resources * occupied by the multi-leveled TPDF cascade structure. **/ static void kair_finalizer(struct kair_class *self) { if (self->extif) destroy_krinst_obj(self->extif); kair_tpdf_cleaning(self); } /*............................................................................. *............................................................................. *................ """ KAIR Major External interfaces """ ..................... *............................................................................. *...........................................................................*/ /** * """ kair_obj_creator() """ * Creates an kair_class instance and returns the address. **/ struct kair_class *kair_obj_creator(const char *alias, unsigned int resilience, unsigned int max_capa, unsigned int min_capa, struct kairistics *kairistic) { struct kair_class *vessel = kzalloc(sizeof(struct kair_class), GFP_ATOMIC); if (!vessel) return 0; *vessel = (struct kair_class) { .df_velocity = KAIR_UNDETERMINED, .resilience = resilience, .ep_ratio = KAIR_BALANCED_EP_RATIO, .max_capa = max_capa, .max_capa = min_capa, .epsilon = 43000, .kairistic = *kairistic, .tpdf_cascade = LIST_HEAD_INIT(vessel->tpdf_cascade), .capa_denom = 0, .stats = {0, 0L, KAIR_DEF_RAND_NEUTRAL, 0}, .initializer = kair_initializer, .stopper = kair_stopper, .finalizer = kair_finalizer, .job_learner = kair_job_probability_collapse, .job_inferer = kair_search_nearest_job_tpdf, .cap_bettor = kair_cap_soft_bettor }; memcpy(&vessel->alias, alias, KAIR_ALIAS_LEN); return vessel; } EXPORT_SYMBOL(kair_obj_creator); /** * """ kair_obj_destructor() """ * Releases the system resources occupied by the instance itself. * @self : the target kair_class instance **/ void kair_obj_destructor(struct kair_class *self) { kfree(self); } EXPORT_SYMBOL(kair_obj_destructor);