what is the diff of cpu lazy and cpu direct in btop ?

[q2333gh]

I am a fan of OS and btop and a programmer.
Curious about this .

[aristocratos]

@q2333gh
"Cpu lazy" sorts the processes by cumulative cpu usage over the processes lifetime. But pushes up processes with current cpu usage over a certain threshold to the top (to not miss current top process).

"Cpu direct" sorts only by current cpu usage.

Overall "Cpu lazy" gives a more stable view of the cpu usage since processes will not be as likely to move around as much compared to when sorting by "direct", and to make it easier to track processes when the update timer is set below maybe 2000-3000 ms (which usually is the case).

btop/src/btop_shared.cpp

Lines 42 to 84 in ad14554

	void proc_sorter(vector<proc_info>& proc_vec, const string& sorting, bool reverse, bool tree) {
	if (reverse) {
	switch (v_index(sort_vector, sorting)) {
	case 0: rng::stable_sort(proc_vec, rng::less{}, &proc_info::pid); break;
	case 1: rng::stable_sort(proc_vec, rng::less{}, &proc_info::name); break;
	case 2: rng::stable_sort(proc_vec, rng::less{}, &proc_info::cmd); break;
	case 3: rng::stable_sort(proc_vec, rng::less{}, &proc_info::threads); break;
	case 4: rng::stable_sort(proc_vec, rng::less{}, &proc_info::user); break;
	case 5: rng::stable_sort(proc_vec, rng::less{}, &proc_info::mem); break;
	case 6: rng::stable_sort(proc_vec, rng::less{}, &proc_info::cpu_p); break;
	case 7: rng::stable_sort(proc_vec, rng::less{}, &proc_info::cpu_c); break;
	}
	}
	else {
	switch (v_index(sort_vector, sorting)) {
	case 0: rng::stable_sort(proc_vec, rng::greater{}, &proc_info::pid); break;
	case 1: rng::stable_sort(proc_vec, rng::greater{}, &proc_info::name); break;
	case 2: rng::stable_sort(proc_vec, rng::greater{}, &proc_info::cmd); break;
	case 3: rng::stable_sort(proc_vec, rng::greater{}, &proc_info::threads); break;
	case 4: rng::stable_sort(proc_vec, rng::greater{}, &proc_info::user); break;
	case 5: rng::stable_sort(proc_vec, rng::greater{}, &proc_info::mem); break;
	case 6: rng::stable_sort(proc_vec, rng::greater{}, &proc_info::cpu_p); break;
	case 7: rng::stable_sort(proc_vec, rng::greater{}, &proc_info::cpu_c); break;
	}
	}
	//* When sorting with "cpu lazy" push processes over threshold cpu usage to the front regardless of cumulative usage
	if (not tree and not reverse and sorting == "cpu lazy") {
	double max = 10.0, target = 30.0;
	for (size_t i = 0, x = 0, offset = 0; i < proc_vec.size(); i++) {
	if (i <= 5 and proc_vec.at(i).cpu_p > max)
	max = proc_vec.at(i).cpu_p;
	else if (i == 6)
	target = (max > 30.0) ? max : 10.0;
	if (i == offset and proc_vec.at(i).cpu_p > 30.0)
	offset++;
	else if (proc_vec.at(i).cpu_p > target) {
	rotate(proc_vec.begin() + offset, proc_vec.begin() + i, proc_vec.begin() + i + 1);
	if (++x > 10) break;
	}
	}
	}
	}

[q2333gh]

aha ! cumulative what a good explanation. i got it . thank you!