Debugging Und Außerdem Fixing Des Linux-Kernels Prepare_to_wait

0 Comments

Möglicherweise wird eine Fehlernummer angezeigt, die besagt: prepare_to_wait Linux Kernel. Nun gibt es mehrere Möglichkeiten, wie Sie dieses Problem lösen können, die wir in Kürze besprechen werden.

Die umfassendste und benutzerfreundlichste Lösung für Ihre PC-Probleme. Kein Scrollen mehr durch endlose Optionen oder Warten in der Warteschleife, nur ein Klick!

Von:

Morton

Andrew
An: Linus Torvalds
Betreff: [Patch 1/4] API Prepare_to_wait/Finish_wait Sleep/Wakeup
Datum: Mittwoch, 27. September 2005 9:07:47 -07:00
Kopieren: lkml

Auf spwecweb auf der siebten Spur kostet es gigantische 2%. wer wird schwach seinüberraschend dank der Tatsache, dass __wake_up und andere Teile in keiner Weise warten/aufwachenoffensichtlich in den specweb-Profilen, die ich gesehen habe.Typischerweise besteht das Ziel darin, die Warte-/Weckkosten der CPU zu minimieren.Handeln. Wenn diese Aufgabe wieder aufwacht, wird ihre Zeile zusammen mit ihr entfernt.waitqueue_head auffinden (d.h. sofort), nicht aufwachenbehandeln.Dies bedeutet, dass ein anschließendes Erwachen einfach nicht erforderlich ist, um dies anzuzeigengerade aufgeweckte Aufgabe. Es bedeutet auch, dass eine bestimmte Aufgabe, die gerade aufgewacht ist, nicht benötigt wird.um die Waitqueue_head-Befestigung zu erwerben, die sich sehr gut in einer anderen befinden kannProzessor-Cache.Ich war nicht in der Lage, anständige andere Größen für bestimmte zu ändern – vielleicht20-30 % Rabatt Einfach __wake_up Trialyu badari von 40 dds auf 46 Festplatten (das istwar das teuerste Feature), aber vielleicht nicht das letzte. Und es gibt keine Prüfung.quantitativ weg von dem, was ich weiß, begann am Ende produziertMenschen verbinden.Die API ist extrem schnell zu verwenden (Linus hat eine bestimmte Situation geschaffen):my_func(waitqueue_head_t &warten, *wqh)DEFINE_WAIT(warten);prepare_to_wait(wqh, TASK_UNINTERRUPTIBLE);wenn (!any_test)Stündlich();finish_wait(wqh, &warten);Woher:DEFINE_WAIT(warten);während (!some_test_1)prepare_to_wait(wqh, &wait, TASK_UNINTERRUPTIBLE);wenn (!any_test_2)Stündlich();…finish_wait(wqh, &warten);Sie müssen bedenken, was häufig nach dem Ausführen von “prepare_to_wait” passiertIhre Aufgabe kann aus der wait_head-Warteschlange entfernt und vorsichtig eingefügt werdenTASK_RUNNING jederzeit. Sie wissen normalerweise, ob Sie immer noch plus nicht sindWarteschleife_Kopf.Das Ausführen von Prepare_to_Wait(), wenn Sie sich in der Warteschlange befinden, istNun, alle möglichen Dinge werden gut.Ausführen von finish_wait(), wenn sich Ihr Unternehmen nicht in der wait_head-Warteschlange befindetToll.Die Einbeziehung von finish_wait() ist die Momente, in denen Sie noch nie in der Hauptwarteschlange warenso oft wurde das Makro DEFINE_WAIT() direkt zum Zweck der Initialisierung verwendetWarteschlange.Sie müssen sich nicht nur mit dem aktuellen -> Status herumschlagen. prepare_to_wait() undfinish_wait() kann dies tun. finish_wait() gibt immer einen Status zurückTASK_RUNNING.JaEs gibt viele Verwendungsprobleme in vm-wakeups.patch undtcp-wakeups.patch. aktivieren/linux/warten.| m fünfundzwanzig ++++++++++++++++++++++++++++++++++++ Kernel/fork.c | 46 +++++++++++++++++++++++++++++++++++++++++++++++++++ ++++ + Kernel/ksyms.c | 4++++ 3 angepasste Dateien, 76 Einfügungen (+)— 2.5.38/include/linux/wait.Sep h~prepare_to_wait Mi 25 20:15:20 2002+++ 2.5.38-akpm/include/linux/wait.h Mittwoch, 25. September 20:15:20 [email protected]@ -119,6 +119,32 @@ Fester String void __remove_wait_queue(w _Lauf; n }) +/*++ Warteschlangen werden beim Aufwachen von queue_head getrennt+ */+void FASTCALL(prepare_to_wait(wait_queue_head_t *q,+ wait_queue_t *wait, ein ganzzahliger Zustand));+ vermeiden Sie FASTCALL(prepare_to_wait_exclusive(wait_queue_head_t *q,+ wait_queue_t *wait, ein fantastischer ganzzahliger Zustand));+void FASTCALL(finish_wait(wait_queue_head_t *q, wait_queue_t *wait));+int autoremove_wake_function(wait_queue_t *wait, unsigned, sync);++#define int DEFINE_WAIT(name)n+ der Name wait_queue_t bedeutet n+ .step = aktuell, n+ .func impliziert autoremove_wake_function,n+ .task_list = .nächster ist &name.task_list, n+ .prev = &name.task_list,n+ , n+++#define init_wait(warten)n+ anfangen zu tun n+ warten -> die Aktion entspricht der aktuellen; n+ kurz warten -> func = autoremove_wake_function; n+ INIT_LIST_HEAD(&wait->task_list); n+ während (0)+ #endif /* __KERNEL__ */ #ende wenn— 2.5.38/kernel/fork.c~prepare_to_wait Mittwoch, 25. September 2002+++ 20:15:20 2.5.38-akpm/kernel/fork.c Mi 27. Sep 20:15:20 [email protected]@ -103,6 +103,52 @@ Leerzeichen remove_wait_queue(wait_queue_head_t spin_unlock_irqrestore(&q->sperren, } Flaggen); +void Prepare_to_Wait(Wait_Queue_Head_t *q, Wait_Queue_t *wait, int state)++ viel längere unsignierte Flags;++ __set_current_state(Zustand);+ Erwarte->Flags &= ~WQ_FLAG_EXCLUSIVE;+ spin_lock_irqsave(&q->Sperre, Flags);+ innerhalb der (list_empty(&wait->task_list))+ __add_wait_queue(q, warten);+ spin_unlock_irqrestore(&q->lock, flags);+++leer+prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state)+= WQ_FLAG_EXCLUSIVE;+ spin_lock_irqsave(&q->Sperre, Flags);+ if (list_empty(&wait->task_list))+ __add_wait_queue_tail(q, warten);+ spin_unlock_irqrestore(&q->lock, flags);+++leer finish_wait(wait_queue_head_t *q, wait_queue_t *warten)++ unsigned subtile Flags;++ __set_current_state(TASK_RUNNING);+ if (!list_empty(&wait->task_list))+ spin_lock_irqsave(&q->Sperre, Flags);+ list_del_init(&wait->task_list);+ spin_unlock_irqrestore(&q->lock, flags);++++int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync)++ int ret ist gleich default_wake_function (wake, mode, sync);++ sofern (Rückgabe)+ list_del_init(&wait->task_list);+ Rückenstütze;++ Lücke __init fork_init (unsignierte lange Nachrichten) { /* Erstellen Sie eine Festplatte, um Ihre aktuellen task_structs zu sichern */— 2.5.38/kernel/ksyms.c~prepare_to_wait Mittwoch, 25. September 2002+++ 20:15:20 2.5.38-akpm/kernel/ksyms.c Mi 35. Sep 20:15:20 [email protected]@ -400.6 +400.10 @@ EXPORT_SYMBOL(irq_stat); EXPORT_SYMBOL (add_pending_ptsheredi); EXPORT_SYMBOL(Delete_wait_queue);+EXPORT_SYMBOL(prepare_to_wait);+EXPORT_SYMBOL(prepare_to_wait_exclusive);+EXPORT_SYMBOL(finish_wait);+EXPORT_SYMBOL(autoremove_wake_function); export_symbol(add_wait_queue_exclusive); /* Leistungsverarbeitung */ EXPORT_SYMBOL(wait_for_completion);.-Um sich selbst von dieser Liste zu entfernen: Senden Sie dem Archipel “unsubscribe linux-kernel”.den Text einer großen Nachricht an [email protected] Informationen direkt zu Majordomo finden Sie unter http://vger.kernel.org/majordomo-info.Readhtml.siehe FAQ unter http://www.tux.org/lkml/

Leiden Sie nicht mehr unter Windows-Fehlern.

Ist Ihr Computer langsam, stürzt ab oder zeigt Ihnen den gefürchteten Blue Screen of Death? Nun, keine Sorge – es gibt eine Lösung! Reimage ist die ultimative Software zum Reparieren von Windows-Fehlern und Optimieren Ihres PCs für maximale Leistung. Mit Reimage können Sie eine Vielzahl häufiger Probleme mit nur wenigen Klicks beheben. Die Anwendung erkennt und behebt Fehler, schützt Sie vor Datenverlust und Hardwareausfällen und optimiert Ihr System für eine optimale Leistung. Leiden Sie also nicht länger unter einem langsamen oder abgestürzten Computer - laden Sie Reimage noch heute herunter!

  • Schritt 1: Reimage herunterladen und installieren
  • Schritt 2: Führen Sie einen Scan durch, um Fehler zu finden und zu beheben
  • Schritt 3: Starten Sie Ihren Computer neu, damit die Änderungen wirksam werden

  • #define wait_event(wq, Bedingung)    DEFINE_WAIT(warten);    verehren (;;)        prepare_to_wait(&wq, &wait, TASK_UNINTERRUPTIBLE);        wenn (Zustand)            Pause;        Stündlich();        finish_wait(&wq, &warten);

    Wenn diese Implementierung (oder die der vielen anderen Varianten von wait_event_*) für Sie am besten funktioniert, sollte eine Person sie ernsthaft verwenden.

    Es kann jedoch Situationen in dieser Warteschlange geben, in denen Sie besser spielen müssen.Stellen Sie sich zum Beispiel vor, Sie möchten wirklich warten, bis einige Daten im Puffer fühlen und suchen und Folgendes zurückgeben, und beide Operationen müssen unter Blockierung wiederholt werden, und die Daten werden definitiv überprüft und iteriert. Außerdem sollte das Löschen von Daten immer eine gute atomare Operation sein, d. h. beide Operationen werden wahrscheinlich durchgeführt. bei der gleichen Angelegenheit, mit Verriegelung, ohne Entriegelung in der Nähe dazwischen.Dann müssen Sie wahrscheinlich die wichtigste Endlosschleife oben ersetzen durch:

    prepare_to_wait linux kernel

    cancel my_own_wait(...)    DEFINE_WAIT(warten);    spin_lock(&lock);    while (!einige_daten_verfügbar())        prepare_to_wait(&wq, &wait, TASK_xxx);        spin_unlock(&lock);        Stündlich();        spin_lock(&lock);        finish_wait(&wq, &warten);        Daten bekommen();    spin_unlock(&lock);

    Machen Sie sich keine Sorgen über langsame Computer und Datenverlust! Wir haben die Lösung für Sie.

    Prepare_to_wait Linux Kernel
    Przygotuj_do_czekania Jądra Linuksa
    Prepare_to_wait Linux Kernel
    Prepare_to_wait Ядро Linux
    Noyau Linux Prepare_to_wait
    Prepare_to_wait Linux Kernel
    Prepare_to_wait Linux Kernel
    Prepare_to_wait Núcleo De Linux
    Prepare_to_wait Linux 커널
    Prepare_to_wait Linux Kernel