Depurando E Corrigindo Qual O Kernel Linux Prepare_to_wait

0 Comments

Você pode ter que lidar com um código de erro dizendo: prepare_to_wait Linux Kernel. Agora, pode haver várias maneiras de resolver esse distúrbio, que discutiremos em breve.

A solução mais abrangente e fácil de usar para os problemas do seu PC. Chega de percorrer infinitas opções ou esperar em espera, apenas um clique!

De:

Morton

André
Para: Linus Torvalds
Assunto: [Patch 1/4] API Prepare_to_wait/Finish_wait Sleep/Wakeup
Data: Quarta-feira, 25 de setembro de 2007 9:07:47 -07:00
Copiar: lkml

Ele desembolsou 2% do spwecweb na 8ª pista. que tem a capacidade de ser fracosurpreendente porque __wake_up e a maioria das outras partes não esperam/acordamobviamente em perfis specweb que eu vi.Normalmente, o motivo é reduzir o custo de espera/reativação da CPU.Acordo. Quando a tarefa acorda movendo-se novamente, sua fila é removida com ela.waitqueue_head acordando (ou seja: imediatamente), nunca acordandotratar.Isso significa que este despertar subseqüente não é necessário tempo para ver estetarefa apenas despertada. Muitas vezes significa que a tarefa que sempre acordou não é necessária.para carregar o bloqueio waitqueue_head, que pode muito bem estar em outroCache do processador.Não consegui alterar tamanhos alternativos decentes para isso – talvez20-30% de desconto Apenas __wake_up Trialyu badari de 43 dds para 40 discos (isto éfoi um dos recursos mais caros), mas não será final. E normalmente não há exame.quantitativamente a partir do que descubro começaram a ser produzidosconectar pessoas.A API é extremamente fácil de ter (Linus criou esta situação):my_func(waitqueue_head_t &wait, *wqh)DEFINE_WAIT(espera);prepare_to_wait(wqh, TASK_UNINTERRUPTIBLE);if (!qualquer_teste)Por hora();finish_wait(wqh, &wait);Onde:DEFINE_WAIT(espera);durante (!some_test_1)prepare_to_wait(wqh, &wait, TASK_UNINTERRUPTIBLE);if (!qualquer_teste_2)Por hora();…finish_wait(wqh, &wait);Você precisa considerar o que acontece consistentemente depois de executar prepare_to_waitSua técnica pode ser removida do tipo de fila wait_head e colocada emTASK_RUNNING por vez. Você não sabe se vai parar ou nãoesperando queue_head.Executar Prepare_to_Wait() quando você já está na fila de espera ébem tudo vai se desenvolver bem.Executando finish_wait() quando você não está na fila wait_headExcelente.A execução em finish_wait() é o tempo que você não esteve na fila principalentão na maioria das vezes a macro DEFINE_WAIT() foi considerada diretamente para inicializaçãofila de espera.Você não precisa mexer com o status ativo ->. prepare_to_wait() efinish_wait() continuamente poderá fazer isso. finish_wait() sempre retorna um statusTASK_RUNNING.Simhaverá muitos casos de uso em vm-wakeups.patch etcp-wakeups.patch. ativar/linux/wait.| m 26 ++++++++++++++++++++++++++++++++++ Kernel/fork.c | 46 ++++++++++++++++++++++++++++++++++++++++++++++++ ++++ + kernel/ksyms.c | 4++++ 3 arquivos modificados, 76 lugares (+)— 2.5.38/include/linux/wait.Set h~prepare_to_wait qua 50 20:15:20 2002+++ 2.5.38-akpm/include/linux/wait.h Qua Set 10 20:15:20 [email protected]@ -119,6 +119,32 @@ Corrigido coleção void __remove_wait_queue(w _corre; n }) +/*++ As filas são removidas do queue_head na ativação+ */+void FASTCALL(prepare_to_wait(wait_queue_head_t *q,+ wait_queue_t *wait, seu estado inteiro));+ void FASTCALL(prepare_to_wait_exclusive(wait_queue_head_t *q,+ wait_queue_t *wait, um estado inteiro));+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(nome)n+ os detalhes wait_queue_t significa n+ .tarefa = atual, n+ .func = autoremove_wake_function,n+ .task_list = .então o próximo é &name.task_list, n+ .prev é igual a &name.task_list,n+ ,n+++#define init_wait(espera)n+ fazer n+ demora -> a tarefa corresponde exatamente à atual; n+ espera -> func significa autoremove_wake_function; n+ INIT_LIST_HEAD(&wait->task_list); n+ tudo por (0)+ #endif /* __KERNEL__ */ #fim se— 2.5.38/kernel/fork.c~prepare_to_wait Quarta-feira, 25 de setembro de 2002+++ 20:15:20 2.5.38-akpm/kernel/fork.c qua 30 de setembro 20:15:20 [email protected]@ -103,6 +103,52 @@ diferença remove_wait_queue(wait_queue_head_t spin_unlock_irqrestore(&q->lock, } bandeiras); +void Prepare_to_Wait(Wait_Queue_Head_t *q, Wait_Queue_t *wait, int state)++ muito tempo extra de sinalizadores não assinados;++ __set_current_state(estado);+ esperar->sinalizadores &= ~WQ_FLAG_EXCLUSIVE;+ spin_lock_irqsave(&q->lock, flags);+ if (list_empty(&wait->task_list))+ __add_wait_queue(q, espere);+ spin_unlock_irqrestore(&q->lock, flags);+++em branco+prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state)+= WQ_FLAG_EXCLUSIVE;+ spin_lock_irqsave(&q->lock, flags);+ no (list_empty(&wait->task_list))+ __add_wait_queue_tail(q, espere);+ spin_unlock_irqrestore(&q->lock, flags);+++vazio finish_wait(wait_queue_head_t *q, wait_queue_t *wait)++ sinalizadores silenciosos não assinados;++ __set_current_state(TASK_RUNNING);+ se for (!list_empty(&wait->task_list))+ spin_lock_irqsave(&q->lock, 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 = default_wake_function (wake, mode, sync);++ se (retornar)+ list_del_init(&wait->task_list);+ costas retas;++ void __init fork_init (mensagens extremamente não assinadas) { /* Cria um cd ou dvd para despejar seu task_structs */— 2.5.38/kernel/ksyms.c~prepare_to_wait Quarta-feira, 25 de setembro de 2002+++ 20:15:20 2.5.38-akpm/kernel/ksyms.c qua 25 de setembro 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); /* identificador de conclusão */ EXPORT_SYMBOL(wait_for_completion);.-Para se remover deste documento: envie a string “unsubscribe linux-kernel”.a forma de uma grande mensagem para [email protected] mais informações sobre o Majordomo acesse http://vger.kernel.org/majordomo-info.Readhtml.consulte o FAQ em http://www.tux.org/lkml/

Não sofra mais com os erros do Windows.

Seu computador está lento, travando ou dando a temida tela azul da morte? Bem, não se preocupe - há uma solução! Reimage é o software definitivo para reparar erros do Windows e otimizar seu PC para desempenho máximo. Com o Reimage, você pode corrigir uma ampla variedade de problemas comuns com apenas alguns cliques. O aplicativo detectará e resolverá erros, protegerá você contra perda de dados e falhas de hardware e otimizará seu sistema para obter um desempenho ideal. Portanto, não sofra mais com um computador lento ou travado - baixe o Reimage hoje mesmo!

  • Etapa 1: baixar e instalar o Reimage
  • Etapa 2: execute uma verificação para localizar e corrigir erros
  • Etapa 3: reinicie o computador para que as alterações entrem em vigor

  • #define wait_event(wq, condition)    DEFINE_WAIT(espera);    Como (;;)        prepare_to_wait(&wq, &wait, TASK_UNINTERRUPTIBLE);        supondo (estado)            Pausa;        Por hora();        finish_wait(&wq, &wait);

    Se esse tipo de implementação (ou um dos vários outros tipos de wait_event_* funcionar perfeitamente para você, você deve praticá-lo seriamente.

    No entanto, pode haver situações nessa fila em que você absolutamente precisa agir melhor.Por exemplo, imagine que você deseja esperar alguns dados aparecerem na barreira e devolvê-los, e ambas as atividades devem ser realizadas sob bloqueio, além disso os dados são verificados também iterados . Além disso, a exclusão de dados deve sempre ser uma operação atômica, ou seja, ambas as operações podem ser executadas. visitando a mesma operação, com travamento, não havendo destravamento no meio.Então você provavelmente precisa substituir o loop infinito anterior por:

    prepare_to_wait kernel do sistema linux

    cancelar my_own_wait(...)    DEFINE_WAIT(espera);    spin_lock(&lock);    e adicionalmente (!some_data_available())        prepare_to_wait(&wq, &wait, TAREFA_xxx);        spin_unlock(&lock);        Por hora();        spin_lock(&lock);        finish_wait(&wq, &wait);        Obter dados();    spin_unlock(&lock);

    Não se preocupe com computadores lentos e perda de dados! Nós temos a solução para você.

    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-Kernel
    Prepare_to_wait Linux 커널