我怎么产生的线上不同的CPU核心?

StackOverflow https://stackoverflow.com/questions/32343

题

我是说我有一个程序在C#没有什么计算昂贵，就像编码清单果文件到Mp3音乐。通常我会编码文件的一个在一段时间，但我们说我想的程序，以找出多少CPU核心我已经和旋转了一个编码线上的每一个的核心。所以，当我运行程序上的四核心CPU，该程序的数字，这是一个四核处理器，数字出有四个核心工作，然后产生四个线程的编码，每个运行在其自己的独立的CPU。我怎么会这么做吗？

并将这是任何不同，如果核心是分散在多个物理Cpu?如果我有一个机与两个核Cpu，是否有任何特别的考虑或是八个核心在两个死亡被认为是相等的，在Windows？

有帮助吗？

解决方案

不要理会这样做。

而不是使用 线的游泳池.该线的游泳池是一个机构(实际上是一类)的框架内，你可以查询为一个新的螺纹。

当你问一个新的螺纹它将给你一个新的或排队的工作，直到一个线程获得释放。在这样的框架是负责在决定是否应该创造更多的线或不取决于本Cpu。

编辑：此外，因为它们已经提到，该系统中充分发线程之间的不同处理器。

其他提示

它是不一定作为简单，只要用线的游泳池。

默认情况下，该线的游泳池分配多线程的每个CPU。由于每个螺纹获得涉及在你正在做的工作具有成本(任务交换的开销、使用的CPU是非常有限的L1,L2也许L3缓存，等等。)，最佳的线程数的使用 <=可用数CPU是，除非每个线程的请求的服务从其他机--例如一个高度可伸缩的网服务。在某些情况下，特别是那些涉及更多的硬盘阅读和写作比CPU活动，实际上你可以变得更好，有1螺纹于多线程。

对于大多数应用，并肯定为声和MP3编码，你应该限制数量的工作人员的线数量提供CPU。这里是一些C#代码中找到的数CPU：

int processors = 1;
string processorsStr = System.Environment.GetEnvironmentVariable("NUMBER_OF_PROCESSORS");
if (processorsStr != null)
    processors = int.Parse(processorsStr);

不幸的是，它不是那么简单，因为限制自己的数量CPU。你也必须考虑到的性能硬盘控制器(s)和光盘(s)。

只有这样，你真的可以找到的最佳数量线是审判一个错误。这尤其是当使用的硬盘，网络服务等。有硬盘，你可能会更好，不使用所有的四个公司在你四处理的CPU。另一方面，有些网络服务，你可能会更好制作10或者甚至100请求每CPU。

在这种情况下的管线的复杂性这样做的是一定程度大于司机的螺纹。这是因为CLR线没有直接关系到一个机OS线。换句话说，CLR可以换一个 管理 线从母线地线，因为它认为合适的。功能 螺纹。BeginThreadAffinity 提供给地方管理线，在锁定的步骤与原OS线。在这一点上，你可以尝试使用机API得到的基本原螺纹处理器的亲和力。每个人都表明，这里，这不是一个非常好的主意。事实上有 文档 这表明线可以获得较少的处理时间，如果他们被限制到一个单一的处理器或核心。

你还可以探索的 系统。诊断。过程 类。还有你可以找到一个功能一一列举过程'的线作为一个集合 ProcessThread 对象。此类具有法设置ProcessorAffinity或甚至设置一个 优选的 处理--不知道那是什么。

免责声明：我已经经历了一个类似的问题在哪里我以为CPU(s)正在利用和研究很多这样的东西；然而，根据所有的，我看，就出现了，是不是一个非常好的想法，作为证明的评论在这里发布。然而，它仍然是有趣和一个学习的经验进行试验。

虽然我同意大多数的答案在这里，我认为这是值得增加一个新的审议：Speed step技术。

时运行的一个CPU密集型的，单线的工作在多核系统，在我的情况一至强E5-2430有6个真正的核心(12HT)下的windows服务器2012年的工作得到了扩展出所有的12个内核，使用周围的8.33%的每个核心和从未触发的速度增加。CPU维持在1.2千兆赫。

当我的纹亲和力的一个具体的核心，它用-100%的核心，造成CPU到最大了在2.5千兆赫，超过一倍的效能。

这是我的使用，这只是循环增加一个变量。当称作用，它将设置的亲和力的核心1.亲和力的一部分是基于 这个职位.

using System;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices;
using System.Threading;

namespace Esquenta
{
    class Program
    {
        private static int numThreads = 1;
        static bool affinity = false;
        static void Main(string[] args)
        {
            if (args.Contains("-a"))
            {
                affinity = true;
            }
            if (args.Length < 1 || !int.TryParse(args[0], out numThreads))
            {
                numThreads = 1;
            }
            Console.WriteLine("numThreads:" + numThreads);
            for (int j = 0; j < numThreads; j++)
            {
                var param = new ParameterizedThreadStart(EsquentaP);
                var thread = new Thread(param);
                thread.Start(j);
            }

        }

        static void EsquentaP(object numero_obj)
        {
            int i = 0;
            DateTime ultimo = DateTime.Now;
            if(affinity)
            {
                Thread.BeginThreadAffinity();
                CurrentThread.ProcessorAffinity = new IntPtr(1);
            }
            try
            {
                while (true)
                {
                    i++;
                    if (i == int.MaxValue)
                    {
                        i = 0;
                        var lps = int.MaxValue / (DateTime.Now - ultimo).TotalSeconds / 1000000;
                        Console.WriteLine("Thread " + numero_obj + " " + lps.ToString("0.000") + " M loops/s");
                        ultimo = DateTime.Now;
                    }
                }
            }
            finally
            {
                Thread.EndThreadAffinity();
            }
        }

        [DllImport("kernel32.dll")]
        public static extern int GetCurrentThreadId();

        [DllImport("kernel32.dll")]
        public static extern int GetCurrentProcessorNumber();
        private static ProcessThread CurrentThread
        {
            get
            {
                int id = GetCurrentThreadId();
                return Process.GetCurrentProcess().Threads.Cast<ProcessThread>().Single(x => x.Id == id);
            }
        }
    }
}

并的结果：

results

处理器速度，如通过任务主管，类似于中央处理器-Z报告：

enter image description here

你不必担心这样做你自己。我有多线程的。净的应用程序运行在双四台机器，并无论如何线开始，无论是通过在线程池或手动，我看到一个很好的，即使分发工作在所有核心。

你绝对可以这样做，通过编写常规内部程序。

但是你不应该试图这样做，因为操作系统是最好的候选人来管理这些东西。我的意思是用户模式程序不应该做的尝试这样做。

然而，有时，它可以做的(对于真正先进的用户)实现的负载平衡以及甚至找到了真正的多线程的多核心问题(数据赛车高速缓冲存储器一致性...)为不同线将是真正执行不同的处理器。

具有说,如果你仍然想要实现我们可以做它在以下方式。我提供你的伪代码(Windows操作系统)，但是他们可以很容易地在Linux上。

#define MAX_CORE 256
processor_mask[MAX_CORE] = {0};
core_number = 0;

Call GetLogicalProcessorInformation();
// From Here we calculate the core_number and also we populate the process_mask[] array
// which would be used later on to set to run different threads on different CORES.


for(j = 0; j < THREAD_POOL_SIZE; j++)
Call SetThreadAffinityMask(hThread[j],processor_mask[j]);
//hThread is the array of handles of thread.
//Now if your number of threads are higher than the actual number of cores,
// you can use reset the counters(j) once you reach to the "core_number".

经过上述程序是所谓的线将始终是执行的方式如下：

Thread1-> Core1
Thread2-> Core2
Thread3-> Core3
Thread4-> Core4
Thread5-> Core5
Thread6-> Core6
Thread7-> Core7
Thread8-> Core8

Thread9-> Core1
Thread10-> Core2
...............

更多信息，请参考手册/MSDN知道更多关于这些概念。

其中每个线去通常是由操作系统本身的...所以产生4个线程上的4个核心系统和操作系统将决定其核心运行每一个月，它通常将1线上的每一个的核心。

它是操作系统的工作的分割线跨越不同的核心，它将这样做时自动当你的线使用了大量的CPU时间。不要担心。至于找出如何多的核心你的用户有，试试 Environment.ProcessorCount 在C#。

你不能这样做，因为只有操作系统拥有权这样做。如果你将决定它。。...然后会难以代码的应用。因为那时你还需要照顾的处理器间的通信。关键部分。每个应用程序必须创建你自己的信号或互斥。.....到其操作系统提供了一个共同的解决方案，通过这样做。...

其中一个原因你不应该(如已所述)试着分配给这种东西你自己，是的，你只是没有足够信息来做正确的，特别是为未来NUMA，等等。

如果你有一个纹读取到运行，并有一个核心空闲，内核 将 运行，你的螺纹，不用担心。

许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top