multithreading - thread - ¿En qué sistema de operación se enhebra la programación suficiente para utilizar múltiples núcleos?

thread python 3 (8)

Me gustaría usar mis habilidades de programación multi-threading (obtuve habilidades), pero me doy cuenta de que eso no es suficiente. Mis hilos aún pueden competir por el mismo núcleo si el sistema operativo no es consciente del potencial. ¿Qué combinación de OS / compilador / biblioteca puedo usar en la arquitectura Intel Xeon para enhebrar los núcleos?

Casi todos los sistemas operativos modernos programarán hilos en múltiples núcleos, AFAIK. Ciertamente, ninguna variante de Unix con la que haya jugado alguna vez tiene el menor problema, y estoy bastante seguro de que todos los Windows se manejan bien. El compilador no es un problema, ya que los subprocesos nativos son algo del nivel del sistema operativo, por lo que el compilador simplemente pasa el syscall hacia abajo.

Hay algunos idiomas (como Ruby) que no usan subprocesos nativos y, en su lugar, usan sus propios subprocesos "verdes", que se implementan en el intérprete y, por lo tanto, se ven como un solo subproceso en el SO, pero son el excepción en lugar de la regla, y por lo general es bastante obvio en los documentos lo que está sucediendo.

Como otros han declarado, cualquier sistema operativo moderno hará esto por usted. Sin embargo, la forma en que lo hace puede tener un gran impacto en el rendimiento, por lo que es probable que desee utilizar hilos de la manera prevista por su sistema operativo. Este artículo de Wikipedia parece tener una visión decente de las técnicas de programación utilizadas por los principales sistemas operativos.

En cada sistema operativo. Esa es más o menos la definición de un hilo.

Si crea una aplicación que inicia dos hilos, entonces el sistema operativo puede ponerlos en dos núcleos separados. Eso es cierto para Windows, OSX, Linux y cualquier otro sistema operativo que se te ocurra.

Hagamos una pequeña distinción. El software que está enhebrado no se ejecutará necesariamente en dos núcleos simultáneamente.

Necesita escribir un código que sea capaz de Multi Threading simultáneo (SMT). La mayoría de los sistemas operativos admiten esto sin problemas; la única diferencia real es la forma en que su software se ocupa del bloqueo y los recursos. Si sus subprocesos dependen de la misma memoria o recursos, habrá disputas y puntos en el tiempo en que uno u otro se paran esperando un recurso, memoria u otro bloqueo.

La mayoría de los lenguajes de programación que tienen subprocesos también son capaces de esto; asegurarse de que se ejecute simultáneamente depende realmente del programador.

Puede encontrar información sobre cómo hacer esto en Windows con Visual Studio C ++ aquí:

http://msdn.microsoft.com/en-us/library/172d2hhw.aspx

Hay muchos tutoriales sobre esto, especialmente para Windows (C #, C ++, VB, etc.). Se pueden encontrar buscando:

http://www.google.com/search?q=simultaneous+multithreading+C%2B%2B

-Adán

Todos los sistemas operativos modernos distribuyen hilos en todos los núcleos disponibles; pero hay varios idiomas o bibliotecas que evitan que esto suceda. los problemas más comunes son:

hilos verdes. solía tener una ventaja de rendimiento cuando las CPU múltiples eran raras y los sistemas operativos no se optimizaban lo suficiente. Hubo un par de máquinas virtuales Java que se jactaban de esto como una característica, más tarde pasaron al esquema M: N, y creo que ahora es N: N en todas partes.
GIL: Global Intepreter Lock. algunos lenguajes de scripting tienen una gran cantidad de estado global en lo profundo del bucle de intérprete, por lo que hay un único bloqueo grande (mutex) para garantizar la coherencia; pero eso evita que dos hilos del mismo "espacio" se ejecuten simultáneamente. Al menos Python y Lua tienen este problema. en estos casos, es preferible utilizar procesos múltiples en lugar de múltiples hilos.

Además, es bueno recordar que el cuello de botella más grande en la mayoría de las aplicaciones vinculadas a la CPU es el ancho de banda RAM, generalmente no la CPU en sí misma, por lo que tener varios hilos luchando por la misma memoria podría no ser el mejor diseño. Por lo general, es mucho mejor refactorizar en varios procesos separados que se comunican a través de mensajes pequeños.

La mayoría de los sistemas operativos modernos están preparados para multiprocesamiento. Por lo tanto, están preparados para multinúcleo. Sin embargo, el planificador es el responsable de distribuir los hilos a los núcleos. Uno de los sistemas operativos multinúcleo y de multiprocesamiento más eficientes es FreeBSD. Sin embargo, no todos los SO son capaces de programar subprocesos para diferentes núcleos. Por ejemplo, el viejo Windows 98 no funciona con más de un núcleo. Además, muchos sistemas operativos tienen restricciones sobre la cantidad máxima de núcleos.

He leído algunas publicaciones en de un usuario que habla sobre un nuevo libro de Packt Publishing y he encontrado el siguiente artículo en la página web de Packt Publishing:

http://www.packtpub.com/article/simplifying-parallelism-complexity-c-sharp

He leído la Programación concurrente con Windows, el libro de Joe Duffy. Ahora, estoy esperando "C # 2008 y 2005 Threaded Programming", el libro de Hillar - http://www.amazon.com/2008-2005-Threaded-Programming-Beginners/dp/1847197108/ref=pd_rhf_p_t_2

En otra publicación, recomendé un nuevo libro. Si está buscando una respuesta profunda, le recomiendo que lea los dos primeros capítulos de "C # 2008 and 2005 threaded programming", de Gaston C. Hillar - Packt Publishing. No supe la respuesta a su pregunta antes de comprar el libro hace 5 días. Ahora, soy capaz de ver cómo mi Core 2 Quad Q6700 alcanza el 98% de la programación de uso de la CPU en C # usando 4 hilos simultáneos. Es más fácil de lo que pensaba. Si tienes conocimiento multihilo, será aún más fácil para ti. Estoy impresionado con los resultados que puedes lograr usando muchos núcleos al mismo tiempo. Recomiendo el libro a aquellos que estén interesados en comenzar con la programación multinúcleo o con hebras usando C #. No soy un programador de C ++. Por esta razón, necesitaba un libro para principiantes C # para explotar múltiples núcleos usando hilos.

Como "tienes habilidades", voy a asumir que ya sabes que prácticamente todos los sistemas operativos modernos ejecutarán tus hilos sobre múltiples núcleos si están disponibles y tus hilos no tienen algún tipo de problema de bloqueo que los haga secuencialmente efectivos. .

Así que voy a adivinar que en realidad estás preguntando cómo unir tus hilos a núcleos para que no compitan entre sí. Esto se hace al configurar la afinidad del procesador del subproceso. A continuación hay enlaces a artículos sobre esto para Windows y Linux. Estoy seguro de que existen otros para otros sabores de Unix también. También notaré que esto generalmente no es necesario, ya que fuera de algunos casos especiales, el sistema operativo sabe mejor dónde programar los hilos que usted. Recuerde, los SO modernos son multiproceso, por lo que sus hilos no solo compiten entre sí, sino que compiten con los hilos de todos los demás procesos del casillero. Dependiendo de la carga, limitar los hilos a un único núcleo puede hacerlos más rápidos.

http://www.microsoft.com/technet/prodtechnol/windows2000serv/reskit/core/fnef_mul_dnpl.mspx?mfr=true

http://www.ibm.com/developerworks/linux/library/l-affinity.html