Felsökning Utöver Fixing The Linux Kernel Prepare_to_wait

0 Comments

Du kan stöta på en felkod som förklarar: prepare_to_wait Linux Kernel. Nu finns det flera sätt att lösa detta problem, som vi kommer att undersöka inom kort.

Den mest omfattande och lättanvända lösningen för dina PC-problem. Inget mer att rulla genom oändliga alternativ eller vänta i väntan, bara ett klick!

Från:

Morton

Andrew
Till: Linus Torvalds
Ämne: [Patch 1/4] API Prepare_to_wait/Finish_wait Sleep/Wakeup
Datum: Onsdag 25 september 2005 9:07:47 -07:00
Kopiera: lkml

Det kostar enorma 2% på spwecweb på 8:e ön. som kommer att vara svagöverraskande bara för att __wake_up och andra delar inte väntar/vaknaruppenbarligen över hela specweb-profilerna jag har sett.Vanligtvis är målet att minska alla CPU:ns vänta/vakna kostnader.Handla. När prestationen vaknar igen tas även dess kö bort tillsammans med den.waitqueue_head väcker det (dvs: omedelbart), vaknar intebehandla.Denna teknik som ett efterföljande uppvaknande är definitivt krävs för att se dettanyss väckt uppdrag. Det betyder också att rollen som precis vaknat inte nödvändigtvis behövs.att skaffa waitqueue_head-låset, vilken typ av kan mycket väl handla om en annanProcessorns cache.Jag har inte kunnat utveckla anständiga olika storlekar för detta i sin tur – kanske20-30 % rabatt Just __wake_up Trialyu badari från 40 dds till 40 enheter (detta ärvar den mest tumme funktionen), men kanske inte är slutgiltig. Och det finns ingen examen.kvantitativt från saker jag vet började produceras särskiltkoppla ihop människor.API:et är extremt lätt att använda (Linus skapade den här situationen):my_func(waitqueue_head_t &wait, *wqh)DEFINE_WAIT(vänta);prepare_to_wait(wqh, TASK_UNINTERRUPTIBLE);om (!något_test)Varje timme();finish_wait(wqh, &wait);Var:DEFINE_WAIT(vänta);under (!något_test_1)prepare_to_wait(wqh, &wait, TASK_UNINTERRUPTIBLE);om (!något_test_2)Varje timme();…finish_wait(wqh, &wait);Du måste föreställa dig vad som ofta händer efter att du har hoppat på prepare_to_waitDin uppgift kan tas bort på grund av wait_head-kön och tryckas inTASK_RUNNING när som helst. Du vet inte om du är stilla eller inteväntar queue_head.Kör Prepare_to_Wait() när du redan har på dig väntekön ärallt kan väl vara bra.Kör finish_wait() när du kanske inte är i wait_head-könBra.Lanseringen av finish_wait() är den tid du aldrig kan ha varit i den stora könså många gånger användes makrot DEFINE_WAIT() direkt för initieringväntande kö.Du behöver inte krångla genom den aktuella -> statusen. prepare_to_wait() ochfinish_wait() kommer sannolikt att kunna göra vår . finish_wait() returnerar alltid någon form av statusTASK_RUNNING.Jadet finns många användningsfall som fungerar i vm-wakeups.patch ochtcp-wakeups.patch. enable/linux/wait.| m 26:e +++++++++++++++++++++++++++++++++ Kärna/gaffel.c | 46 ++++++++++++++++++++++++++++++++++++++++++++ ++++ + kernel/ksyms.c | 4++++ 3 modifierade dokumentationer, 76 bilagor (+)— 2.5.38/include/linux/wait.Sep h~prepare_to_wait Ons 25 20:15:20 2002+++ 2.5.38-akpm/include/linux/wait.h ons 25 sep 2002 20:15:[email protected]@ -119.6 +119.32 @@ Fixed string void __remove_wait_queue(w _springa; n }) +/*++ Köer tas bort utanför queue_head vid uppvakning+ */+void FASTCALL(prepare_to_wait(wait_queue_head_t *q,+ wait_queue_t *wait, ett heltalstillstånd));+ värdelös FASTCALL(prepare_to_wait_exclusive(wait_queue_head_t *q,+ wait_queue_t *wait, ett nytt heltalstillstånd));+void FASTCALL(finish_wait(wait_queue_head_t *q, wait_queue_t *wait));+int autoremove_wake_function(wait_queue_t *vänta, osignerad, synkronisera);++#define int DEFINE_WAIT(namn)n+ något slags namn wait_queue_t betyder n+ .task är lika med aktuell, n+ .func = autoremove_wake_function,n+ .task_list betyder att .next är &namn.task_list, n+ .prev är lika med &name.task_list,n+ , n+++#define init_wait(wait)n+ skriv n+ vänta -> uppgiften jämförs med den nuvarande; n+ håll den -> func = autoremove_wake_function; n+ INIT_LIST_HEAD(&wait->uppgiftslista); n+ under (0)+ #endif /* __KERNEL__ */ #slut om— 2.5.38/kernel/fork.c~prepare_to_wait Onsdag trettio september 2002+++ 20:15:20 2.5.38-akpm/kernel/fork.c Ons 27 Sep 20:15:20 [email protected]@ -103,6 +103,52 @@ rumsutrymme remove_wait_queue(wait_queue_head_t spin_unlock_irqrestore(&q->lås, } flaggor); +void Prepare_to_Wait(Wait_Queue_Head_t *q, Wait_Queue_t *wait, int state)++ en hel del längre osignerade flaggor;++ __set_nuvarande_tillstånd(tillstånd);+ förvänta->flaggor &= ~WQ_FLAG_EXCLUSIVE;+ spin_lock_irqsave(&q->lås, flaggor);+ i fall där (list_empty(&wait->task_list))+ __add_wait_queue(q, vänta);+ spin_unlock_irqrestore(&q->lås, flaggor);+++tomt+prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state)+= WQ_FLAG_EXCLUSIVE;+ spin_lock_irqsave(&q->lås, flaggor);+ en gång (list_empty(&wait->task_list))+ __add_wait_queue_tail(q, vänta);+ spin_unlock_irqrestore(&q->lås, flaggor);+++tom finish_wait(wait_queue_head_t *q, wait_queue_t *wait)++ osignerade tysta flaggor;++ __set_current_state(TASK_RUNNING);+ if (!list_empty(&wait->task_list))+ spin_lock_irqsave(&q->lås, flaggor);+ list_del_init(&vänta->uppgiftslista);+ spin_unlock_irqrestore(&q->lås, flaggor);++++int autoremove_wake_function(wait_queue_t *wait, osignerat läge, int sync)++ int ret är lika med default_wake_function (wake, mode, sync);++ var (retur)+ list_del_init(&vänta->uppgiftslista);+ tillbaka ret;++ void __init fork_init (osignerade långa meddelanden) { /* Skapa en disk för att dumpa dina personliga task_structs */— 2.5.38/kernel/ksyms.c~prepare_to_wait onsdag 25 september 2002+++ 20:15:20 2.5.38-akpm/kernel/ksyms.c ons 5 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(förbereda_att_vänta);+EXPORT_SYMBOL(förbereda_att_vänta_exklusivt);+EXPORT_SYMBOL(avsluta_vänta);+EXPORT_SYMBOL(autoremove_wake_function); export_symbol(add_wait_queue_exclusive); /* slutbearbetning */ EXPORT_SYMBOL(vänta_på_avslut);.-För att ta bort dig själv direkt från den här listan: skicka den strängade “unsubscribe linux-kernel”.innehållet i en enorm lektion till [email protected]ör mer information om Majordomo se http://vger.kernel.org/majordomo-info.Readhtml.se FAQ för http://www.tux.org/lkml/

Lid inte längre av Windows-fel.

Körs din dator långsamt, kraschar eller ger dig den fruktade Blue Screen of Death? Tja, oroa dig inte - det finns en lösning! Reimage är den ultimata programvaran för att reparera Windows-fel och optimera din dator för maximal prestanda. Med Reimage kan du fixa ett stort antal vanliga problem med bara några klick. Applikationen kommer att upptäcka och lösa fel, skydda dig från dataförlust och maskinvarufel och optimera ditt system för optimal prestanda. Så lida inte längre av en långsam eller kraschad dator - ladda ner Reimage idag!

  • Steg 1: Ladda ner och installera Reimage
  • Steg 2: Kör en skanning för att hitta och åtgärda fel
  • Steg 3: Starta om datorn för att ändringarna ska träda i kraft

  • #define wait_event(wq, condition)    DEFINE_WAIT(vänta);    liknar (;;)        prepare_to_wait(&wq, &wait, TASK_UNINTERRUPTIBLE);        antar (tillstånd)            Paus;        Varje timme();        finish_wait(&wq, &wait);

    Om den här implementeringen (eller en mot många andra smaker om wait_event_* fungerar bäst för dig, bör du seriöst använda den.

    Det kan dock finnas situationer i den här kön i vem du behöver för att agera bättre.För typ, föreställ dig att du vill vänta med att vissa data ska visas bufferten och returnera den, utöver det måste båda operationerna utföras som anges nedan blockering, och data är tartan och itererad. Omläggning av data bör också alltid vara en fischer-operation, dvs båda operationerna kan utföras mer. vid samma operation, genom låsning, utan upplåsning däremellan.Då måste du förmodligen ersätta den gränslösa slingan ovan med:

    prepare_to_wait unix like kernel

    avbryt my_own_wait(...)    DEFINE_WAIT(vänta);    spin_lock(&lås);    medan (!some_data_available())        prepare_to_wait(&wq, &wait, TASK_xxx);        spin_unlock(&lås);        Varje timme();        spin_lock(&lås);        finish_wait(&wq, &wait);        hämta data();    spin_unlock(&lås);

    Oroa dig inte för långsamma datorer och dataförlust! Vi har lösningen för dig.

    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 Núcleo De Linux
    Prepare_to_wait-Linux-Kernel
    Prepare_to_wait Linux 커널
    Prepare_to_wait Linux Kernel