Instancias del programador

En este documento se describe el rol de las instancias de programador del runtime de simultaneidad y cómo usar las clases Concurrency::Scheduler y Concurrency::CurrentScheduler para crear y administrar instancias de programador. Las instancias de programador son útiles cuando desea asociar directivas de programación explícitas con tipos concretos de cargas de trabajo. Por ejemplo, puede crear una instancia de programador para ejecutar algunas tareas con una prioridad elevada de subproceso y usar el programador predeterminado para ejecutar con otras tareas con la prioridad normal de subproceso.

Sugerencia
El runtime de simultaneidad proporciona un programador predeterminado y, por tanto, no es necesario crear uno en la aplicación. Puesto que el programador de tareas ayuda a optimizar el rendimiento de las aplicaciones, se recomienda que comience con Parallel Patterns Library (PPL) o Biblioteca de agentes asincrónicos si no ha usado antes el runtime de simultaneidad.

Secciones

• Las clases CurrentScheduler y Scheduler

• Crear una instancia del Programador

• Administrar la duración de una instancia de programador

• Métodos y características

• Ejemplo

Las clases CurrentScheduler y Scheduler

El Programador de tareas permite a las aplicaciones utilizar una o varias instancias del programador para programar el trabajo. La clase Concurrency::Scheduler representa una instancia de programador y encapsula la funcionalidad relacionada con la programación de tareas.

Un subproceso que se adjunta a un programador se conoce como contexto de ejecución o simplemente contexto. Un programador puede estar activo en el contexto actual en cualquier momento. El programador activo también es conocido como programador actual. El runtime de simultaneidad usa la clase Concurrency::CurrentScheduler para proporcionar acceso al programador actual. El programador actual de un contexto puede diferir del programador de otro contexto. El runtime no proporciona ninguna representación de nivel de proceso del programador actual.

Normalmente, la clase CurrentScheduler se utiliza para tener acceso al programador actual. La clase Scheduler resulta útil si necesita administrar un programador que no es el actual.

En las siguientes secciones se describe cómo crear y administrar una instancia del programador. Para obtener un ejemplo completo que ilustre estas tareas, vea Cómo: Administrar una instancia del programador.

[Ir al principio]

Crear una instancia del Programador

Hay tres maneras de crear un objeto Scheduler:

• Si no existe ningún programador, el runtime crea uno predeterminado para que pueda utilizar la funcionalidad en tiempo de ejecución, por ejemplo, un algoritmo paralelo, para llevar a cabo el trabajo. El programador predeterminado se convierte en el programador actual para el contexto que inicia el trabajo paralelo.

• El método Concurrency::CurrentScheduler::Create crea un objeto Scheduler que usa una directiva concreta y asocia ese programador al contexto actual.

• El método Concurrency::Scheduler::Create crea un objeto Scheduler que usa una directiva concreta, pero no lo asocia al contexto actual.

Permitir que el runtime cree un programador predeterminado posibilita que todas las tareas simultáneas compartan el mismo programador. Normalmente, la funcionalidad que proporciona la Biblioteca de modelos de procesamiento paralelo (PPL) o la Biblioteca de agentes asincrónicos se usa para realizar trabajo paralelo. Por consiguiente, no tiene que trabajar directamente con el programador para controlar su directiva o duración. Al utilizar PPL o la Biblioteca de agentes, el runtime crea el programador predeterminado si no existe y lo convierte en el programador actual para cada contexto. Cuando se crea un programador y se establece como el programador actual, el runtime usa ese programador para programar tareas. Cree instancias adicionales del programador solo cuando necesite una directiva de programación concreta. Para obtener más información sobre las directivas asociadas a un programador, vea Directivas del programador.

[Ir al principio]

Administrar la duración de una instancia de programador

El runtime utiliza un mecanismo de recuento de referencias para controlar la duración de los objetos Scheduler.

Al utilizar el método CurrentScheduler::Create o Scheduler::Create para crear un objeto Scheduler, el runtime establece el recuento de referencias inicial de ese programador en uno. El runtime incrementa el recuento de referencias cuando se llama al método Concurrency::Scheduler::Attach. El método Scheduler::Attach asocia el objeto Scheduler junto con el contexto actual. Esto lo convierte en el programador actual. Al llamar al método CurrentScheduler::Create, el tiempo de ejecución crea un objeto Scheduler y lo adjunta al contexto actual (y establece el recuento de referencias en uno). También puede usar el método Concurrency::Scheduler::Reference para incrementar el recuento de referencias de un objeto Scheduler.

El runtime disminuye el recuento de referencias cuando se llama al método Concurrency::CurrentScheduler::Detach para desasociar el programador actual o se llama al método Concurrency::Scheduler::Release. Cuando el recuento de referencias llega a cero, el runtime destruye el objeto Scheduler cuando todas las tareas programadas finalizan. Una tarea en ejecución puede incrementar el recuento de referencias del programador actual. Por consiguiente, si el recuento de referencias llega a cero y una tarea incrementa el recuento de referencias, el runtime no destruye el objeto Scheduler hasta que el recuento de referencias llega a cero de nuevo y finalizan todas las tareas.

El runtime mantiene una pila interna de los objetos Scheduler para cada contexto. Cuando se llama al método CurrentScheduler::Create o Scheduler::Attach, el runtime empuja el objeto Scheduler hacia la pila del contexto actual. Esto lo convierte en el programador actual. Al llamar a CurrentScheduler::Detach, el runtime saca el programador de la pila para el contexto actual y establece el anterior como programador actual.

El runtime proporciona varias maneras de administrar la duración de una instancia del programador. En la siguiente tabla se muestra el método adecuado que libera o desasocia el programador del contexto actual para cada método que crea o adjunta un programador al contexto actual.

Llamar al método de liberar o asociar incorrecto genera un comportamiento no especificado en el runtime.

Cuando usa funcionalidad, por ejemplo, PPL hace que el runtime cree el programador predeterminado, no libera ni desasocia este programador. El runtime administra la duración de cualquier programador que cree.

Como el runtime no destruye un objeto Scheduler antes de que todas las tareas hayan finalizado, puede usar el método Concurrency::Scheduler::RegisterShutdownEvent o Concurrency::CurrentScheduler::RegisterShutdownEvent para recibir una notificación cuando se destruye un objeto Scheduler. Esto es útil cuando hay que esperar a que finalice cada tarea programada por un objeto Scheduler.

[Ir al principio]

Métodos y características

En esta sección se resumen los métodos importantes de las clases Scheduler y CurrentScheduler.

Piense en la clase CurrentScheduler como una aplicación auxiliar para crear un programador que se usará en el contexto actual. La clase Scheduler permite controlar un programador que pertenece a otro contexto.

En la tabla siguiente se muestran los métodos importantes definidos por la clase CurrentScheduler.

En la tabla siguiente se muestran los métodos importantes definidos por la clase Scheduler.

[Ir al principio]

Ejemplo

Para obtener ejemplos básicos sobre cómo crear y administrar una instancia de programador, vea Cómo: Administrar una instancia del programador.

Vea también

Conceptos

Programador de tareas (Runtime de simultaneidad)

Otros recursos

Cómo: Administrar una instancia del programador

Directivas del programador

Grupos de programación

Historial de cambios