Analyse der Initialisierung des Quellcodes des Linux-Kernel-Schedulers

void __init sched_init(void)
{
    vorzeichenloser langer ptr = 0;
    int ich;
 
    /*
     * Initialisieren Sie die globale Standarddatenstruktur zur Steuerung der CPU-Bandbreite für RT und DL *
     * rt_bandwidth und dl_bandwidth werden hier verwendet, um die globale DL- und RT-Bandbreitennutzung zu steuern und zu verhindern, dass der Echtzeitprozess zu viel CPU verwendet, was zu einem Verhungern des normalen CFS-Prozesses führen würde */
    init_rt_bandwidth(&def_rt_bandwidth, global_rt_period(), global_rt_runtime());
    init_dl_bandwidth(&def_dl_bandwidth, global_rt_period(), global_rt_runtime());
 
#ifdef CONFIG_SMP
    /*
     * Initialisieren Sie die Standard-Stammdomäne *
     * Die Root-Domäne ist eine wichtige Datenstruktur für den globalen Ausgleich von Echtzeitprozessen wie dl/rt. Am Beispiel von rt ist * root_domain->cpupri die höchste Priorität der RT-Aufgabe, die auf jeder CPU innerhalb der Root-Domäne ausgeführt wird, sowie * die Verteilung von Aufgaben mit unterschiedlicher Priorität auf der CPU. Durch die Daten von cpupri wird in rt Enqueue/Dequeue
     * Wenn der RT-Scheduler sicherstellen kann, dass Aufgaben mit hoher Priorität basierend auf der RT-Aufgabenverteilung zuerst ausgeführt werden*/
    init_defrootdomain();
#endif
 
#ifdef CONFIG_RT_GROUP_SCHED
    /*
     * Wenn der Kernel die RT-Gruppenplanung (RT_GROUP_SCHED) unterstützt, kann die Bandbreitensteuerung für RT-Aufgaben mithilfe von cgroup erfolgen.
     * Die Granularität wird verwendet, um die CPU-Bandbreitennutzung von RT-Aufgaben in jeder Gruppe zu steuern*
     * RT_GROUP_SCHED ermöglicht RT-Aufgaben, die Bandbreite als Ganzes in Form von CPU-Kontrollgruppen zu steuern. * Dies kann die RT-Bandbreitensteuerung flexibler machen (ohne RT_GROUP_SCHED kann nur die globale * Bandbreitennutzung von RT gesteuert werden, und die Bandbreite einiger RT-Prozesse kann nicht durch Angabe einer Gruppe gesteuert werden).
     */
    init_rt_bandwidth(&root_task_group.rt_bandwidth,
            global_rt_period(), global_rt_runtime());
#endif /* CONFIG_RT_GROUP_SCHED */
 
    /* Initialisiere die Ausführungswarteschlange für jede CPU */
    für_jede_mögliche_CPU(i) {
        Struktur rq *rq;
 
        rq = cpu_rq(i);
        raw_spin_lock_init(&rq->Sperre);
        /*
         * Initialisieren Sie die Ausführungswarteschlange von cfs/rt/dl auf rq. * Jeder Planungstyp hat seine eigene Ausführungswarteschlange auf rq und jede Planungsklasse verwaltet ihren eigenen Prozess. * Bei pick_next_task() wählt der Kernel Aufgaben von hoch nach niedrig entsprechend der Reihenfolge der Priorität der Planungsklasse aus. * Dadurch wird sichergestellt, dass Aufgaben der Planungsklasse mit hoher Priorität zuerst ausgeführt werden. *
         * Stop und Idle sind spezielle Planungstypen, die für spezielle Zwecke entwickelt wurden und es Benutzern nicht erlauben, * Prozesse des entsprechenden Typs zu erstellen, sodass der Kernel keine entsprechenden Ausführungswarteschlangen in rq entwirft */
        cfs_rq(&rq->cfs);
        init_rt_rq(&rq->rt);
        init_dl_rq(&rq->dl);
#ifdef CONFIG_FAIR_GROUP_SCHED
        /*
         * CFS-Gruppenplanung (group_sched), kann CFS über die CPU-Steuerungsgruppe steuern * kann eine CPU-Verhältnissteuerung zwischen Gruppen über cpu.shares bereitstellen (verschiedene Steuerungsgruppen können die CPU entsprechend den entsprechenden * Verhältnissen gemeinsam nutzen) und kann auch Quoten über cpu.cfs_quota_us festlegen (ähnlich der * Bandbreitensteuerung von RT). Die Bandbreitenkontrolle von CFS group_sched ist eine der grundlegenden Technologien für die Containerimplementierung*
         * root_task_group ist die standardmäßige Root-Task-Group, andere CPU-Kontrollgruppen verwenden sie als * übergeordnetes Element oder Vorgängerelement. Die Initialisierung hier verknüpft root_task_group mit der CFS-Ausführungswarteschlange von rq*. Was hier gemacht wird, ist sehr interessant. Direktes Setzen von root_task_group->cfs_rq[cpu] = &rq->cfs
         * Auf diese Weise wird der Prozess unter der CPU-Cgroup-Root oder der sched_entity der Cgroup tg direkt zu rq->cfs hinzugefügt
         * In der Warteschlange kann der Suchaufwand um eine Ebene reduziert werden.
         */
        root_task_group.shares = ROOT_TASK_GROUP_LOAD;
        INIT_LIST_HEAD(&rq->leaf_cfs_rq_list);
        rq->tmp_alone_branch = &rq->leaf_cfs_rq_list;
        init_cfs_bandwidth(&root_task_group.cfs_bandwidth);
        init_tg_cfs_entry(&root_task_group, &rq->cfs, NULL, i, NULL);
#endif /* CONFIG_FAIR_GROUP_SCHED */
 
        rq->rt.rt_runtime = def_rt_bandwidth.rt_runtime;
#ifdef CONFIG_RT_GROUP_SCHED
        /* Initialisiere die RT-Ausführungswarteschlange auf rq, ähnlich der Gruppenplanungsinitialisierung von CFS oben*/
        init_tg_rt_entry(&root_task_group, &rq->rt, NULL, i, NULL);
#endif
 
#ifdef CONFIG_SMP
        /*
         * Hier wird rq mit der Standard-Def_Root_Domain verknüpft. Wenn es sich um ein SMP-System handelt, erstellt der Kernel später in sched_init_smp eine neue Root_Domain und ersetzt diese Def_Root_Domain
         */
        rq_attach_root(rq, &def_root_domain);
#endif /* CONFIG_SMP */
    }
 
    /*
     * Registrieren Sie die Soft-Interrupt-Servicefunktion SCHED_SOFTIRQ von CFS. * Dieser Soft-Interrupt ist für den periodischen Lastausgleich und den Leerlauflastausgleich vorbereitet. */
    init_sched_fair_class();
 
    scheduler_running = 1;
}

/*
 * Wird vom Bootprozessor aufgerufen, um den Rest zu aktivieren.
 *
 * In der SMP-Architektur muss BSP alle anderen Nicht-Boot-CPs hochfahren
 */
void __init smp_init(void)
{
    int Anzahl Knoten, Anzahl CPUs;
    vorzeichenlose Ganzzahl CPU;
 
    /* Für jede CPU einen inaktiven Thread erstellen */
    idle_threads_init();
    /* CPUHP-Thread beim Kernel registrieren */
    cpuhp_threads_init();
 
    pr_info("Sekundäre CPUs werden hochgefahren ...\n");
 
    /*
     * FIXME: Dies sollte im Userspace erfolgen --RR
     *
     * Wenn die CPU nicht online ist, rufen Sie sie mit cpu_up auf
     */
    für_jede_vorhandene_CPU(CPU) {
        wenn (Anzahl_Online-CPUs() >= Setup_Max_CPUs)
            brechen;
        wenn (!cpu_online(cpu))
            cpu_up(Zentrale CPU);
    }
     
    .............
}

/*
 * Topologieliste, Bottom-Up.
 *
 * Standardmäßige physikalische Topologie unter Linux *
 * Hier gibt es nur drei Ebenen der physischen Topologie, und die NUMA-Domäne wird in sched_init_numa() automatisch erkannt. * Wenn eine NUMA-Domäne vorhanden ist, wird die entsprechende NUMA-Planungsdomäne hinzugefügt. *
 * Hinweis: Die standardmäßige Planungsdomäne default_topology kann einige Probleme aufweisen. Beispielsweise haben einige Plattformen keine DIE-Domänen (Intel-Plattformen), sodass sich LLC- und DIE-Domänen überschneiden können. * Nachdem die Planungsdomäne eingerichtet wurde, durchsucht der Kernel daher alle Planungen in cpu_attach_domain(). * Wenn es eine Planungsüberschneidung gibt, wird die überlappende Planungsdomäne entsprechend destroy_sched_domain*/ zerstört.
statische Struktur sched_domain_topology_level default_topology[] = {
#ifdef CONFIG_SCHED_SMT
    { cpu_smt_mask, cpu_smt_flags, SD_INIT_NAME(SMT) },
#endif
#ifdef CONFIG_SCHED_MC
    { CPU-Kerngruppenmaske, CPU-Kernflags, SD_INIT_NAME(MC) },
#endif
    { cpu_cpu_mask, SD_INIT_NAME(DIE) },
    { NULL, },
};

/*
 * Initialisierung der NUMA-Planungsdomäne (Erstellen einer neuen physischen Topologiestruktur „sched_domain_topology“ basierend auf Hardwareinformationen)
 *
 * Der Kernel fügt die NUMA-Topologie standardmäßig nicht aktiv hinzu, Sie müssen sie konfigurieren (wenn NUMA aktiviert ist)
 * Wenn NUMA aktiviert ist, muss anhand der Hardwaretopologieinformationen bestimmt werden, ob die Domäne * sched_domain_topology_level hinzugefügt werden soll (erst nach dem Hinzufügen dieser Domäne erstellt der Kernel die NUMA-DOMÄNE, wenn * sched_domain später initialisiert wird).
 */
void sched_init_numa(void)
{
    ................
    /*
     * Hier prüfen wir, ob basierend auf der Entfernung eine NUMA-Domäne (auch mehrere NUMA-Domänen) vorhanden ist, und aktualisieren sie dann basierend auf der * Situation auf die physische Topologiestruktur. Wenn Sie später eine Planungsdomäne erstellen, verwenden Sie diese neue *physische Topologie, um eine neue Planungsdomäne zu erstellen*/
    für (j = 1; j < Ebene; i++, j++) {
        tl[i] = (Struktur sched_domain_topology_level){
            .mask = sd_numa_mask,
            .sd_flags = cpu_numa_flags,
            .flags = SDTL_OVERLAP,
            .numa_level = j,
            SD_INIT_NAME(NUMA)
        };
    }
 
    sched_domain_topology = tl;
 
    sched_domains_numa_levels = Ebene;
    sched_max_numa_distance = sched_domains_numa_distance[Ebene - 1];
 
    init_numa_topology_type();
}

/*
 * Planerdomänen und -gruppen einrichten. Dies schließt vorerst nur isolierte
 * CPUs, könnte aber in Zukunft verwendet werden, um andere Sonderfälle auszuschließen.
 */
int sched_init_domains(const struct cpumask *cpu_map)
{
    int err;
 
    zalloc_cpumask_var(&sched_domains_tmpmask, GFP_KERNEL);
    zalloc_cpumask_var(&sched_domains_tmpmask2, GFP_KERNEL);
    zalloc_cpumask_var(&fallback_doms, GFP_KERNEL);
 
    arch_update_cpu_topology();
    ndoms_cur = 1;
    doms_cur = alloc_sched_domains(ndoms_cur);
    wenn (!doms_cur)
        doms_cur = &fallback_doms;
    /*
     * doms_cur[0] gibt die CPU-Maske an, die die Scheduling-Domäne überschreiben muss
     *
     * Wenn isolcpus= verwendet wird, um einige CPUs im System zu isolieren, werden diese CPUs nicht zur Planungsdomäne * hinzugefügt, d. h. diese CPUs nehmen nicht am Lastausgleich teil (der Lastausgleich umfasst hier DL/RT und CFS).
     * Hier wird „isolate“ von cpu_map und housekeeping_cpumask(HK_FLAG_DOMAIN) verwendet.
     * CPU wird entfernt, um sicherzustellen, dass die isolierte CPU nicht in der etablierten Planungsdomäne enthalten ist
     */
    cpumask_and(doms_cur[0], cpu_map, housekeeping_cpumask(HK_FLAG_DOMAIN));
    /* Implementierungsfunktion zum Einrichten der Planungsdomäne*/
    Fehler = build_sched_domains(doms_cur[0], NULL);
    register_sched_domain_sysctl();
 
    Rückgabefehler;
}

/*
 * Erstellen Sie Sched-Domänen für eine bestimmte Anzahl von CPUs und hängen Sie die Sched-Domänen an
 * zu den einzelnen CPUs
 */
statische int
build_sched_domains(const struct cpumask *cpu_map, struct sched_domain_attr *attr)
{
    Aufzählung s_alloc alloc_state = sa_none;
    Struktur sched_domain *sd;
    Struktur s_data d;
    Struktur rq *rq = NULL;
    : Int i, ret = -ENOMEM;
    Struktur sched_domain_topology_level *tl_asym;
    bool has_asym = falsch;
 
    wenn (WARN_ON(cpumask_empty(cpu_map)))
        gehe zu Fehler;
 
    /*
     * Die meisten Prozesse in Linux werden von CFS geplant, sodass sched_domain in CFS häufig aufgerufen und geändert wird (z. B. nohz_idle und verschiedene Statistiken in sched_domain). Daher wird sched_domain
     * Beim Design muss der Effizienz Priorität eingeräumt werden, daher verwendet der Kernel die Percpu-Methode, um sched_domain zu implementieren
     * Jede SD-Ebene zwischen CPUs ist eine unabhängig angewendete Percpu-Variable, sodass die Eigenschaften von Percpu verwendet werden können, um das Problem der Parallelitätskonkurrenz zwischen ihnen zu lösen * (1. Kein Sperrschutz erforderlich. 2. Keine Cacheline-Pseudofreigabe).
     */
    alloc_state = __visit_domain_allocation_hell(&d, cpu_map);
    wenn (alloc_state != sa_rootdomain)
        gehe zu Fehler;
 
    tl_asym = asym_cpu_capacity_level(cpu_map);
 
    /*
     * Richten Sie Domänen für die durch die CPU-Map angegebenen CPUs ein:
     *
     * Hier werden wir alle CPUs in cpu_map durchlaufen und entsprechende physische Topologiestrukturen für diese CPUs erstellen (
     * mehrstufige Planungsdomäne von for_each_sd_topology).
     *
     * Wenn die Planungsdomäne eingerichtet ist, wird der der CPU in der Planungsdomäne auf dieser Ebene entsprechende Bereich über tl->mask(cpu) abgerufen (dh die CPU und andere entsprechende CPUs bilden diese Planungsdomäne). Die der CPU in derselben Planungsdomäne entsprechende SD wird zu Beginn auf dieselbe initialisiert (einschließlich sd->pan,
     * sd->imbalance_pct und sd->flags).
     */
    für_jede_CPU(i, CPU-Map) {
        Struktur sched_domain_topology_level *tl;
 
        sd = NULL;
        für_jede_SD-Topologie(tl) {
            int dflags = 0;
 
            wenn (tl == tl_asym) {
                dflags |= SD_ASYM_CPUCAPACITY;
                hat_asym = wahr;
            }
 
            sd = build_sched_domain(tl, cpu_map, attr, sd, dflags, i);
 
            wenn (tl == sched_domain_topology)
                *pro_cpu_ptr(d.sd, i) = sd;
            wenn (tl->flags & SDTL_OVERLAP)
                sd->flags |= SD_OVERLAP;
            wenn (cpumask_equal(cpu_map, sched_domain_span(sd)))
                brechen;
        }
    }
 
    /*
     * Erstellen Sie die Gruppen für die Domänen
     *
     * Erstellen Sie eine Dispatch-Gruppe *
     * Die Rolle von sched_group können wir anhand der Implementierung von zwei Planungsdomänen erkennen: * 1. NUMA-Domäne 2. LLC-Domäne *
     * numa sched_domain->span umfasst alle CPUs in der NUMA-Domäne. Wenn ein Ausgleich erforderlich ist, * sollten NUMA-Domänen nicht auf CPUs basieren, sondern auf Sockets, d. h. nur Socket1 und Socket2
     * Die CPU wird nur dann zwischen den beiden Sockeln migriert, wenn ein extremes Ungleichgewicht besteht. Wenn sched_domain zur Implementierung dieser * Abstraktion verwendet wird, führt dies zu unzureichender Flexibilität (wie in der MC-Domäne unten zu sehen ist). Daher verwendet der Kernel sched_group zur * Darstellung eines CPU-Satzes und jeder Socket gehört zu einer sched_group. Eine Migration ist nur zulässig, wenn die beiden Sched_Groups nicht im Gleichgewicht sind*
     * Die MC-Domäne ist ähnlich. Die CPU kann zwar Hyperthreading haben, aber die Leistung des Hyperthreadings entspricht nicht der des physischen Kerns. Ein Paar* Hyperthreads entspricht ungefähr der 1,2-fachen Leistung eines physischen Kerns. Daher müssen wir beim Planen das Gleichgewicht zwischen Hyperthreading*-Paaren berücksichtigen, das heißt, wir müssen zuerst das Gleichgewicht zwischen den CPUs und dann das Gleichgewicht des Hyperthreadings innerhalb der CPU herstellen. Zu diesem Zeitpunkt wird sched_group zur Abstraktion verwendet. Eine sched_group repräsentiert eine physische CPU (zwei Hyperthreads). Zu diesem Zeitpunkt stellt LLC das Gleichgewicht zwischen den CPUs sicher und vermeidet so eine extreme Situation: das Gleichgewicht zwischen den Hyperthreads, aber das Ungleichgewicht auf den physischen Kernen. Gleichzeitig kann sichergestellt werden, dass der Kernel beim Planen und Auswählen von Kernen den physischen Threads Vorrang einräumt. Erst wenn die physischen Threads aufgebraucht sind, wird die Verwendung eines anderen Hyperthreads in Betracht gezogen, sodass das System die Rechenleistung der CPU besser nutzen kann.
    für_jede_CPU(i, CPU-Map) {
        für (sd = *per_cpu_ptr(d.sd, i); sd; sd = sd->parent) {
            sd->span_weight = cpumask_weight(sched_domain_span(sd));
            wenn (sd->flags & SD_OVERLAP) {
                wenn (build_overlap_sched_groups(sd, i))
                    gehe zu Fehler;
            } anders {
                wenn (build_sched_groups(sd, i))
                    gehe zu Fehler;
            }
        }
    }
 
    /*
     * Berechnen Sie die CPU-Kapazität für physische Pakete und Knoten
     *
     * sched_group_capacity wird verwendet, um die für sg verfügbare CPU-Leistung anzugeben*
     * sched_group_capacity berücksichtigt die unterschiedliche Rechenleistung der einzelnen CPUs (unterschiedliche Maximalfrequenzeinstellungen,
     * ARM große und kleine Kerne usw.), entfernen Sie die vom RT-Prozess verwendete CPU (sg ist für CFS vorbereitet, daher ist es erforderlich, * die vom DL/RT-Prozess auf der CPU verwendete CPU-Rechenleistung zu entfernen) usw., sodass die verfügbare Rechenleistung für CFS sg übrig bleibt (weil * beim Lastausgleich nicht nur die Belastung der CPU berücksichtigt werden sollte, sondern auch das CFS auf diesem sg
     * Verfügbare Rechenleistung. Wenn es auf dieser SG weniger Prozesse gibt, aber die sched_group_capacity auch klein ist, sollten Prozesse nicht auf diese SG migriert werden)
     */
    für (i = nr_cpumask_bits-1; i >= 0; i--) {
        wenn (!cpumask_test_cpu(i, cpu_map))
            weitermachen;
 
        für (sd = *per_cpu_ptr(d.sd, i); sd; sd = sd->parent) {
            Anspruchszuweisungen(i, sd);
            init_sched_groups_capacity(i, sd);
        }
    }
 
    /* Domänen anhängen */
    rcu_read_lock();
    /*
     * Binden Sie das rq jeder CPU an rd (root_domain) und prüfen Sie, ob sd überlappt. * Wenn ja, wird destroy_sched_domain() verwendet, um es zu entfernen (so können wir sehen, dass * Intel-Server nur 3 Planungsdomänen haben und die DIE-Domäne sich tatsächlich mit der LLC-Domäne überschneidet, also wird sie hier entfernt)
     */
    für_jede_CPU(i, CPU-Map) {
        rq = cpu_rq(i);
        sd = *per_cpu_ptr(d.sd, i);
 
        /* Verwenden Sie READ_ONCE()/WRITE_ONCE(), um Lade-/Speicherfehler zu vermeiden: */
        wenn (rq->cpu_capacity_orig > EINMALIGES LESEN(d.rd->max_cpu_capacity))
            EINMALIGE SCHREIBUNG(d.rd->max_cpu_capacity, rq->cpu_capacity_orig);
 
        cpu_attach_domain(sd, d.rd, i);
    }
    rcu_read_unlock();
 
    wenn (hat_asym)
        static_branch_inc_cpuslocked(&sched_asym_cpucapacity);
 
    wenn (rq && sched_debug_enabled) {
        pr_info("Stammdomänenspanne: %*pbl (max. CPU-Kapazität = %lu)\n",
            cpumask_pr_args(cpu_map), rq->rd->max_cpu_capacity);
    }
 
    ret = 0;
Fehler:
    __free_domain_allocs(&d, alloc_state, cpu_map);
 
    Rückkehr ret;
}