Add a way to differentiate between P and E cores

[Nerez83]

Is your feature request related to a problem? Please describe.
Just to see how much the E/P cores are utilized. Can be good to know especially on laptops.

Describe the solution you'd like
If the CPU supports it, instead of having for example C0 - C19, show for example P0 - P11 and E12 - E19.

Describe alternatives you've considered
Checking the /sys/devices/cpu_core/cpus file or the /sys/devices/cpu_atom/cpus file.

Additional context
I don't know how it is on other devices but on my Intel laptop in the file /sys/devices/cpu_core/cpus is stored a range of the core IDs that are performance cores and in the file /sys/devices/cpu_atom/cpus is stored a range of the core IDs that are efficiency cores.

[Nerez83]

A quick and dirty implementation in the src/btop_draw.cpp file, there is probably a better way of doing it but this works.
(For more context, in the files is just for example 0-11.)

@@ -877,9 +877,38 @@
                //? Core text and graphs
                int cx = 0, cy = 1, cc = 0, core_width = (b_column_size == 0 ? 2 : 3);
                if (Shared::coreCount >= 100) core_width++;
+
+               // Detect P/E cores
+               static int p_core_start = 0;
+               static int p_core_end = -1;
+               static bool core_types_loaded = false;
+               static bool has_performance_cores = false;
+
+               if (!core_types_loaded) {
+                       core_types_loaded = true;
+                       std::ifstream cpu_core_file("/sys/devices/cpu_core/cpus");
+                       if (cpu_core_file.is_open()) {
+                               std::string core_range;
+                               cpu_core_file >> core_range;
+                               if (!core_range.empty()) {
+                                       size_t dash_pos = core_range.find('-');
+                                       if (dash_pos != std::string::npos) {
+                                               p_core_start = std::stoi(core_range.substr(0, dash_pos));
+                                               p_core_end = std::stoi(core_range.substr(dash_pos + 1));
+                                               has_performance_cores = true;
+                                       }
+                               }
+                       }
+               }
+
                for (const auto& n : iota(0, Shared::coreCount)) {
                        auto enabled = is_cpu_enabled(n);
-                       out += Mv::to(b_y + cy + 1, b_x + cx + 1) + Theme::c(enabled ? "main_fg" : "inactive_fg") + (Shared::coreCount < 100 ? Fx::b + 'C' + Fx::ub : "")
+                       char core_prefix = 'C';
+                       if (has_performance_cores) {
+                               core_prefix = (n >= p_core_start && n <= p_core_end ? 'P' : 'E');
+                       }
+
+                       out += Mv::to(b_y + cy + 1, b_x + cx + 1) + Theme::c(enabled ? "main_fg" : "inactive_fg") + (Shared::coreCount < 100 ? Fx::b + core_prefix + Fx::ub : "")
                                + ljust(to_string(n), core_width);
                        if ((b_column_size > 0 or extra_width > 0) and cmp_less(n, core_graphs.size()))
                                out += Theme::c("inactive_fg") + graph_bg * (5 * b_column_size + extra_width) + Mv::l(5 * b_column_size + extra_width)

[netkv]

Also on meteor lake and higher, e vs lpe core distinction would be nice
there doesn't seem clean way to distinguish those from /sys but ig caches (esp that lpe cores lack L3) and clocks could tell?
screenshot of lscpu -e on my u9 185h