lib/kair.c - LeafOS-Devices/android_kernel_samsung_exynos9820 - Gitiles

 /**
  *
  * 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 <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/kair.h>

 #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[] = "<!DOCTYPE html><html><head><title>Kair TPDF description</title></head><body lang=\"en\"><table width=\"100\%\" cellpadding=\"4\" cellspacing=\"0\">";
 const char __hcmp_entr[] = "<tr valign=i\"top\"><td><p>level ";
 const char __hcmp_flr1[] = " TPDF shape</p><p><br></p><p>- randomness : ";
 const char __hcmp_flr2[] = "</p><p>- observation interval : ";
 const char __hcmp_flr3[] = "</p><p>- weight : ";
 const char __hcmp_iter[] = "</p></td><td><p>";
 const char __hcmp_clsr[] = "</p></td></tr>";
 const char __hcmp_foot[] = "</table></body></html>\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);