То, как управлять, которые удаляют сердцевину процесса, работает?

Обычно решение, о котором удаляют сердцевину приложения, будет работать, сделан системой. Однако можно установить "привязку" к приложению к определенному ядру, чтобы сказать ОС только запускать приложение на том ядре. Обычно это не хорошая идея, но существуют некоторые редкие случаи, где она могла бы иметь смысл.

, Чтобы сделать это в окнах, используйте диспетчер задач, щелкните правой кнопкой по процессу и выберите "Set Affinity". Можно сделать это программно в Windows с помощью функций как SetThreadAffinityMask, SetProcessAffinityMask или SetThreadIdealProcessor.

ETA:

, Если Вы интересуетесь тем, как ОС на самом деле делает планирование, Вы могли бы хотеть проверить эти ссылки:

статья Wikipedia о контекстном переключении

статья Wikipedia о Планировании планирования

в ядре Linux

С самой современной ОС, ОС планирует поток для выполнения на ядре для короткой части времени. Когда интервал времени истекает, или поток делает операцию IO, которая заставляет его добровольно приводить к ядру, ОС запланирует другой поток для работы ядра (если будут какие-либо потоки, готовые работать). Точно то, какой поток планируется, зависит от алгоритма планирования ОС.

детали реализации точно, как контекстное переключение происходит, являются ЦП & зависимый от операционной системы. Это обычно будет включать переключатель к привилегированному режиму, ОС, сохраняющая состояние предыдущего сообщения, загружая состояние нового потока, затем переключаясь назад на непривилегированный режим и возобновляя недавно загруженный поток. Статья контекстного переключения, которую я связал с вышеупомянутым, имеет немного больше детали об этом.

Как другие упомянули, этим управляет операционная система. В зависимости от ОС это может или не может предоставить Вам системные вызовы, которые позволяют Вам влиять на то, на каком ядре данный процесс выполняется. Однако необходимо обычно просто позволять ОС сделать поведение по умолчанию. Если у Вас есть система с 4 ядрами с 37 выполнениями процессов, и 34 из тех процессов спят, они собираются запланировать оставление 3 активными процессами на отдельные ядра.

Вы будете, вероятно, только видеть повышение скорости при игре с базовым сродством в очень специализированных многопоточных приложениях. Например, предположите, что у Вас есть система с 2 двухъядерными процессорами. Предположим, что у Вас есть приложение с 3 потоками, и два из потоков воздействуют в большой степени на тот же набор данных, тогда как третий поток использует другой набор данных. В этом случае Вы извлекли бы выгоду больше всего при наличии двух потоков, которые взаимодействуют на том же процессоре и третьем потоке на другом процессоре, с тех пор они могут совместно использовать кэш. ОС понятия не имеет, к какой памяти каждый поток должен получить доступ, таким образом, это не может выделить потоки ядрам соответственно.

, Если Вы интересуетесь , как операционная система, читайте на планирование . Вшивые песчаные детали многопроцессорной обработки на x86 могут быть найдены в Руководства Разработчика программного обеспечения Архитектуры Intel 64 и IA-32 . Объем 3 А, Главы 7 и 8 содержат релевантную информацию, но принимают во внимание, что эти руководства являются чрезвычайно техническими.

ОС знает, как сделать это, Вы не имеете к. Вы могли столкнуться со всеми видами проблем, если бы Вы определили, на каком ядре работать, некоторые из которых могли на самом деле замедлить процесс. Позвольте ОС понять это, просто необходимо начать новую дискуссию.

, Например, если бы Вы сказали процессу запускаться на ядре x, но ядро x уже находилось под большой нагрузкой, Вы оказались бы в худшем положении, чем если бы Вы только что позволили ОС обработать его.

Я не знаю инструкции по сборке. Но API-функция окон SetProcessAffinityMask. Вы видите пример из чего-то, что я починил только что для выполнения Picasa только на одном ядре

Ничто не говорит ядру "сейчас запустите этот процесс".

Ядро не видит процесс, он знает только об исполняемом коде и различных уровнях выполнения и связанных ограничениях на команды, которые могут быть выполнены.

Когда компьютер загружается, для простоты только одно ядро ​​/ процессор активен и фактически выполняет любой код. Затем, если ОС поддерживает мультипроцессор, она активирует другие ядра с помощью какой-то специфической для системы инструкции, другие ядра, скорее всего, получают из того же места, что и другое ядро, и запускаются оттуда.

Итак, что делает планировщик, это просматривает внутренние структуры ОС ( очередь задач / процессов / потоков) и выбирает один и помечает его как работающий в его ядре. Тогда другие экземпляры планировщика, работающие на других ядрах, выиграли Не трогайте его до тех пор, пока задача снова не перейдет в состояние ожидания (и не будет помечена как прикрепленная к конкретному ядру). После того, как задача помечена как выполняемая, планировщик выполняет переключение на пользовательское пространство с возобновлением задачи с того момента, на котором она была ранее приостановлена.

Технически ничто не мешает ядрам запускать один и тот же код в одно и то же время (и многие разблокированные функции делают это), но если код не написан так, чтобы ожидать этого, он, вероятно, разозлится сам по себе.

Сценарий становится все более странным с более экзотическими моделями памяти (выше подразумевается «обычная» линейная единичная рабочая область памяти), где ядра не обязательно все видят одну и ту же память и могут быть требования по извлечению кода из других ядер, но это гораздо проще сделать, просто прикрепив задачу к ядру (архитектура AFAIK Sony PS3 с SPU такая же).

The OpenMPI project has a library to set the processor affinity on Linux in a portable way.

Some while back, I have used this in a project and it worked fine.

Caveat: I dimly remember that there were some issues in finding out how the operating system numbers the cores. I used this in a 2 Xeon CPU system with 4 cores each.

A look at cat /proc/cpuinfo might help. On the box I used, it is pretty weird. Boiled down output is at the end.

Evidently, the evenly numbered cores are on the first cpu and the oddly numbered cores are on the second cpu. However, if I remember correctly, there was an issue with the caches. On these Intel Xeon processors, two cores on each CPU share their L2 caches (I do not remember whether the processor has an L3 cache). I think that the virtual processors 0 and 2 shared one L2 cache, 1 and 3 shared one, 4 and 6 shared one and 5 and 7 shared one.

Because of this weirdness (1.5 years back I could not find any documentation on the process numbering in Linux), I would be careful do do this kind of low level tuning. However, there clearly are some uses. If your code runs on few kinds of machines then it might be worth to do this kind of tuning. Another application would be in some domain specific language like StreamIt where the compiler could do this dirty work and compute a smart schedule.

processor       : 0
physical id     : 0
siblings        : 4
core id         : 0
cpu cores       : 4

processor       : 1
physical id     : 1
siblings        : 4
core id         : 0
cpu cores       : 4

processor       : 2
physical id     : 0
siblings        : 4
core id         : 1
cpu cores       : 4

processor       : 3
physical id     : 1
siblings        : 4
core id         : 1
cpu cores       : 4

processor       : 4
physical id     : 0
siblings        : 4
core id         : 2
cpu cores       : 4

processor       : 5
physical id     : 1
siblings        : 4
core id         : 2
cpu cores       : 4

processor       : 6
physical id     : 0
siblings        : 4
core id         : 3
cpu cores       : 4

processor       : 7
physical id     : 1
siblings        : 4
core id         : 3
cpu cores       : 4