标签: multicore

在Windows XP上的多核机器上,单个进程的线程是并行运行的吗？在不同的Windows版本上行为是否相同(Windows服务器版本)

我听说只有不同进程的线程并行运行.

有没有简单的方法来制作2个方法,假设MethodA()和MethodB()在2个不同的核心中运行？我不是指2个不同的线程.我在Windows中运行,但我想知道是否可以独立于平台.

编辑:那怎么样

http://docs.python.org/dev/library/multiprocessing.html 和 parallel python？

我正在尝试在OS X 10.5上的GHC 6.10.4(来自MacPorts)中运行并行代码

我在makefile中使用-threaded构建:

GHC=ghc -prof -auto-all -O -threaded

glicko: glicko.hs Lib.hs
        $(GHC) --make -main-is Glicko glicko.hs lib.hs

当我调用./glicko +RTS -N或./glicko +RTS -N1代码运行时,似乎只使用一个CPU.如果我调用as ./glicko +RTS -N2,那么我将获得记录命令行参数的运行时帮助消息; 但是文档表明这应该运行该程序.

为什么-N2不起作用？

这里有更多时间信息:

$ ./glicko +RTS --info
 [("GHC RTS", "YES")
 ,("GHC version", "6.10.4")
 ,("RTS way", "rts_thr_p")
 ,("Host platform", "i386-apple-darwin")
 ,("Host architecture", "i386")
 ,("Host OS", "darwin")
 ,("Host vendor", "apple")
 ,("Build platform", "i386-apple-darwin")
 ,("Build architecture", "i386")
 ,("Build OS", "darwin")
 ,("Build vendor", "apple")
 ,("Target platform", "i386-apple-darwin")
 ,("Target architecture", "i386")
 ,("Target OS", …

我需要在我的多核桌面上并行化CPU密集型Java应用程序,但我对线程编程不太满意.我看了Scala,但这意味着要学习一种非常耗时的新语言.我还看了Ateji PX Java并行扩展,看起来很容易使用,但还没有机会评估它.有人会推荐吗？欢迎其他建议.

在此先感谢您的帮助

法案

对于大量多线程的Java服务器应用程序,建议使用更多CPU内核(6个而不是4个)或更高的CPU频率(2.53 Ghz而不是2.4 Ghz).

在我看来,显然更多核心是要走的路,但我想听听第二个意见.

谢谢.

嘿伙计们,
我正在阅读这些所谓的非阻塞技术,但我几乎没有怀疑:

1)使用原子操作执行无锁操作,现在这些原子操作是什么？我的意思是在一定程度上他们还需要锁定吗？那么这种无锁方法是否只能让我们以更精细的粒度锁定？
2)他们说非阻塞列表,现在应该是一个非阻塞列表:如果同一个插入的多个线程出现,只有一个会成功,另一个会做其他工作吗？,但是如果除了插入一个节点,其他线程别无选择,那么它是如何进行非阻塞的呢？它不会被阻止,直到前一个完成？
3)在java中,它们如何进行原子操作？他们不是这样做的, synchronized boolean ..... 因为他们正在获取锁定即同步部分,它是如何无锁的？4)CAS通常用于实现原子操作.那么cas不允许在同一个对象上只发生一个操作,并停止(阻止)那些想要在同一个对象上操作的人吗？很抱歉这么多疑惑......请澄清......

编辑 当我有更新结构时会发生什么？它也受硬件支持吗？没有权利,那么语言是否会在某种程度上获取锁定以使这些结构操作成为原子？
关于JAVA:有AtomicReference和AtomicReferenceFieldUpdater类,它为对象(结构或任何类型的对象)提供更新,所以我们可以在性能方面比较它们,我的意思是速度吗？在tern中都使用了使用Native类的Unsafe类.

我正在尝试这两个基准测试(软件事务内存和原子操作,我猜两者都不一样),虽然我没有做太多使用STM(似乎很难使用),但我成功尝试计数基准,即所有线程将共享计数器递增50,000次,并注意到原子操作比STM更好.
所以我想知道,因为STM尚未完全开发,它们在现实情况下是否比原子操作表现良好？
有一个人因为表现而转向其他人吗？请分享信息..
我在网上找到的相关日志是没有锁的并发编程

PS我使用JAVA作为编程语言.STM: - 多节.AtomicOperatinn:AtomicInteger.

在多核系统中,例如2,4或8个内核,我们通常使用互斥锁和信号量来访问共享内存.但是,我可以预见,这些方法会为具有许多内核的未来系统带来很高的开销.是否有任何替代方法可以更好地用于未来许多用于访问共享内存的核心系统.

如果这个代码在多个内核上运行多个线程没有任何性能优势,我就不会感到头疼.但它怎么能真正运行得慢？

首先看一下代码:

class ThreadSafeStack
  def initialize
    @s,@m = [],Mutex.new
  end
  def push(value)
    @m.synchronize { @s.push(value) }
  end
  def pop
    @m.synchronize { @s.pop }
  end
  def peek
    @m.synchronize { @s.last }
  end
end

完整的基准测试脚本位于https://github.com/alexdowad/showcase/blob/master/ruby-threads/concurrent_stack.rb.基本上,我做了一百万次推送,一百万次偷窥和一百万次流行音乐,分为1个,5个或25个线程(并行运行).

运行JRuby 1.6.5.1的4核Mac Pro的结果:

Testing ThreadSafeStack with 1 thread, iterating 1000000x each
  1.575000   0.000000   1.575000 (  1.575000)
Testing ThreadSafeStack with 5 threads, iterating 200000x each
  4.838000   0.000000   4.838000 (  4.838000)
Testing ThreadSafeStack with 25 threads, iterating 40000x each
 11.409000   0.000000  11.409000 ( 11.409000)

是什么赋予了？？？ …

不知道多核并行化。但是对于简单的循环，它可能几乎没有修改。对于以下示例，如何在 VC++ 中使用多核计算进行简单循环？

#include <iostream>
#include <vector>
#include <ctime>
using namespace std;

void foo(int n, double* a, double* b, double *c, double*d, double* e, double* f, double* g)
{
    for (int i = 0; i < n; ++i)
    {
        a[i] = b[i] * a[i] + c[i] * (d[i] + e[i] + f[i] + g[i]);
    }
}

int main()
{
    int m = 1001001;
    vector<double> a(m), b(m), c(m), d(m), f(m);

    std::clock_t startcputime = std::clock();
    for (int i = 0; i < …

我在一台机器上有64个内核,运行排序总计1GB的数据.它们每个排序156,250项,不应共享任何数据结构(即总共有64个单独的数组被排序).但是,我运行的核心越多,每个核心在其自己的排序任务中的速度就越慢.

时间测量正在这样做:

void sort_ranges(std::vector<std::vector<std::vector<int> > > & range_partitions, int num_workers, std::string filename, std::string outfile)
{
  #pragma omp parallel default(none) shared(range_partitions, outfile, num_workers)
  {
    int i = omp_get_thread_num();
    std::vector<int> data_vec; //Data copied into separate data structure for each thread
    for(int x = 0; x < num_workers; x ++) {
      data_vec.reserve(data_vec.size() + (range_partitions[x][i]).size());
      data_vec.insert(data_vec.end(), range_partitions[x][i].begin(), range_partitions[x][i].end());
    }
    int n = data_vec.size();
    int * data = &data_vec[0];
    double start = omp_get_wtime();
    std::sort(data, data + n); //Measure sort function call
    double sort_done = omp_get_wtime() …

我试图使用线程多次执行单个程序(在核心之间分配负载).我有两个核心,所以我需要制作两个线程.当一个线程完成时,该线程需要再次重用才能执行.我怎么会这样做我迷失了

有很多文章讨论多核神话。为了真正受益于多个内核，需要编写并行算法。他们中许多人提到阿姆达尔定律。

为了简单起见，假设我们有一台带有4核商品CPU的台式计算机。并假设目标是提高我们的应用程序性能以及整体系统性能。

我想知道如何使用CPU内核来执行任务。

• 是否将单个进程的线程分配给所有内核
• 或者将来自不同进程的线程安排在不同的内核上运行。

如果是后者，那为什么还要讨论神话呢？即使所有进程都是单线程的，多任务OS也不总是受益于多核CPU吗？来自同一进程的线程是否更有可能在多个内核上同时调度？

• 有哪些重要因素？CPU缓存可能吗？可能与某些应用程序相关？为什么？
• 您为什么要使用并行库/算法？毕竟，CPU资源在所有正在运行的进程之间共享，并且总是有足够的资源。

是否有一个“主动过程”概念？即，最受调度程序关注的过程。如果是这样，那么此过程通常会引起多少关注？