Establecimiento de prioridad de subprocesos en Linux con Boost

Question

Las bibliotecas Boost no parecen tener un dispositivo para establecer la prioridad de un subproceso. ¿Sería este el mejor código para usar en Linux o hay un método mejor?

boost::thread myThread(MyFunction()); 

struct sched_param param; 
param.sched_priority = 90; 
pthread_attr_setschedparam(myThread.native_handle(), SCHED_RR, &param); 

No tengo mucha experiencia en programación de Linux.

Answer 1

Esa es la plantilla básica de cómo lo haría, pero después de buscar no encontré ejemplos de código, así que creo que el veredicto es si es mejor o no.

El problema es que impulso :: hilo no tiene un constructor que permite a los atributos para ser aprobada en la creación del hilo en pthead lo que tiene que hacer cambios después de que el hilo se inicia. La única otra manera que conozco para solucionarlo es a través de la herencia de proceso/programación de hilos. A menos que se indique lo contrario, los hilos nuevos heredarán el cronograma/prioridad de su creador para que pueda cambiar el hilo actual antes de crear los hilos de trabajo y luego cambiarlos si lo desea. Parece incómodo, pero es una alternativa.

Aquí hay un truco de un ejemplo que con suerte demuestra ambos. Es posible que deba cambiar la política y la prioridad según corresponda y ejecutar como root.

Tenga cuidado con la forma de establecer la prioridad. Se aplican varias restricciones.

#include <iostream> 
#include <boost/thread/thread.hpp> 
#include <unistd.h> 
#include <sched.h> 
#include <cstdio> 


void* threadfunc() 
{ 
    sleep(5); 
} 

void displayAndChange(boost::thread& daThread) 
{ 
    int retcode; 
    int policy; 

    pthread_t threadID = (pthread_t) daThread.native_handle(); 

    struct sched_param param; 

    if ((retcode = pthread_getschedparam(threadID, &policy, &param)) != 0) 
    { 
     errno = retcode; 
     perror("pthread_getschedparam"); 
     exit(EXIT_FAILURE); 
    } 

    std::cout << "INHERITED: "; 
    std::cout << "policy=" << ((policy == SCHED_FIFO) ? "SCHED_FIFO" : 
           (policy == SCHED_RR) ? "SCHED_RR" : 
           (policy == SCHED_OTHER) ? "SCHED_OTHER" : 
                 "???") 
       << ", priority=" << param.sched_priority << std::endl; 


    policy = SCHED_FIFO; 
    param.sched_priority = 4; 

    if ((retcode = pthread_setschedparam(threadID, policy, &param)) != 0) 
    { 
     errno = retcode; 
     perror("pthread_setschedparam"); 
     exit(EXIT_FAILURE); 
    } 

    std::cout << " CHANGED: "; 
    std::cout << "policy=" << ((policy == SCHED_FIFO) ? "SCHED_FIFO" : 
           (policy == SCHED_RR) ? "SCHED_RR" : 
           (policy == SCHED_OTHER) ? "SCHED_OTHER" : 
                  "???") 
       << ", priority=" << param.sched_priority << std::endl; 
} 


int main(int argc, char* argv[]) 
{ 
    int policy, res; 

    struct sched_param param; 

    if ((policy = sched_getscheduler(getpid())) == -1) 
    { 
     perror("sched_getscheduler"); 
     exit(EXIT_FAILURE); 
    } 

    if ((res = sched_getparam(getpid(), &param)) == -1) 
    { 
     perror("sched_getparam"); 
     exit(EXIT_FAILURE); 
    } 

    std::cout << " ORIGINAL: "; 
    std::cout << "policy=" << ((policy == SCHED_FIFO) ? "SCHED_FIFO" : 
           (policy == SCHED_RR) ? "SCHED_RR" : 
           (policy == SCHED_OTHER) ? "SCHED_OTHER" : 
                  "???") 
       << ", priority=" << param.sched_priority << std::endl; 


    policy = SCHED_RR; 
    param.sched_priority = 2; 

    if ((res = sched_setscheduler(getpid(), policy, &param)) == -1) 
    { 
     perror("sched_setscheduler"); 
     exit(EXIT_FAILURE); 
    } 

    boost::thread t1(&threadfunc); 

    displayAndChange(t1); 

    t1.join(); 

    return 0; 
} 

Answer 2

No creo que Linux realmente tiene prioridades de los hilos - en la mayoría de los núcleos se pueden utilizar niveles 'agradable', pero eso es probablemente por ello (lo que simplificaría el programador) - Sin embargo, no todos los sistemas Linux respeto eso! (Depende del planificador).

Answer 3

Puede echar un vistazo a esta biblioteca (escrito por un estudiante en la mía, no publicado aún, mirar el repositorio SVN): https://sourceforge.net/projects/threadutility/

Básicamente, él escribió un envoltorio del impulso :: hilo que permite especificar y establecer las prioridades de los hilos de manera portátil, seleccionando la implementación interna correcta según la plataforma (actualmente Linux o Windows). En Linux, el código usa el syscall sched_setscheduler().

Answer 4

boost::thread tiene la capacidad de admitir atributos pthread antes de llamar al pthread_create(). Proporciona el tipo boost::thread::attributes, que solo se puede usar para establecer el tamaño de pila (en los sistemas que lo admiten), pero también presenta un método .get_native_handle(), que devuelve pthread_attr_t, en el que puede establecer los atributos que desee. A continuación, puede simplemente llamar al make_thread() con ese objeto boost::thread::attributes como argumento. Consulte los cuadros de códigos segundo y tercero en esta sección: http://www.boost.org/doc/libs/1_53_0/doc/html/thread/thread_management.html#thread.thread_management.tutorial.attributes