多线程OR多进程-访存密集型应用

hy036630

zylthinking 发表于 2011-12-29 18:32
你这话说的， 8个核的8个线程能不比一个线程高么， 问题是你 ／8 以后相比单线程性能有没有下降， 以及 ...

是说的单线程能力呢  8个线程的时候 单线程能力比一个线程还快

zylthinking

hy036630 发表于 2011-12-29 18:34
是说的单线程能力呢  8个线程的时候 单线程能力比一个线程还快

做的工作也一样？ 不会一个做了全套， 一个做了其中的 1/8 吧； 主要是如果下降， 或者持平还能理解， 他还能比单线程快， 就有些不明白了

hy036630

zylthinking 发表于 2011-12-29 18:36
做的工作也一样？ 不会一个做了全套， 一个做了其中的 1/8 吧； 主要是如果下降， 或者持平还能理解，  ...

能够理解  呵呵  现在的SMP是共享最后一级缓存的 如图，所以后面的几个线程不需要从内存load数据 所以速度有提高可以理解

zylthinking

hy036630 发表于 2011-12-29 18:38
能够理解  呵呵  现在的SMP是共享最后一级缓存的 如图，所以后面的几个线程不需要从内存load数据 所以速度 ...

那不对， 从你的 event 看， 8个线程第一个将其load 进cache, 剩下的直接读； 但单线程不也是将其load进cache? 每一个 event 都有一个load 的动作， 怎么会提高？

何况， 多核是共享一级缓存的， 莫非多CPU也共享么， 你这个图也画的是没共享嘛

zylthinking

zylthinking 发表于 2011-12-29 18:41
那不对， 从你的 event 看， 8个线程第一个将其load 进cache, 剩下的直接读； 但单线程不也是将其load进 ...

能想到的一个理由是8线程争夺运行权的能力提升了， 原来是 1/(others + 1), 现在成了 8/(others + 8 )

qsc555

template<class T>
class RingQueue {
public:

    RingQueue() {
        cout << "RingQueue::ctor" << endl;
    };

    virtual ~RingQueue() {
        cout << "RingQueue::destory" << endl;
    };

    void InitQueue() {
        Push_Count = 0;
        Push_Index = 0;
        Pop_Count = 0;
        Pop_Index = 0;
        memset(List, 0, sizeof (List));
    }

    bool Push(const T& AData) {
        if (Push_Count - Pop_Count < Max_Count) {
            List[Push_Index] = AData;
            Push_Count++;
            if (Push_Index == High_Index)
                Push_Index = 0;
            else
                Push_Index++;
            return true;
        } else
            return false;
    }
    T Pop() {
        T result = NULL;
        if (Push_Count != Pop_Count) {
            result = List[Pop_Index];
            Pop_Count++;
            if (Pop_Index == High_Index)
                Pop_Index = 0;
            else
                Pop_Index++;
        }
        return result;
    }

    long size() {
        return this->Push_Count - this->Pop_Count;
    }

private:
    RingQueue(const RingQueue& orig);
    T List[524288 * 2]; //2^19  4M�ռ�
    const static unsigned long Max_Count = 524288 * 2;
    const static unsigned long High_Index = 524288 * 2 - 1;
    unsigned long Push_Count;
    unsigned long Push_Index;
    unsigned long Pop_Count;
    unsigned long Pop_Index;

};
---------------------------------------------------------无奈的分割线
之前的“编译器乱序优化”，我开始说Pop()函数里改成if (Push_Count > Pop_Count)可以避免，想到溢出时的情况就不成立了，改成if (Push_Count - Pop_Count > 0)就好，但Push函数也会有类似的问题，就是在环形队列满的时候，所以我改成如下：

    bool Push(const T& AData) {
        if (size()  < Max_Count) {//环形队列不满
            if(List[Push_Index]  != NULL)//这时候元素还没被pop出去
                  return false;
            List[Push_Index] = AData;
            Push_Count++;
            if (Push_Index == High_Index)
                Push_Index = 0;
            else
                Push_Index++;
            return true;
        } else
            return false;
    }
    T Pop() {
        T result = NULL;
        if (size() > 0) {//环形队列不为空
            result = List[Pop_Index];
            Pop_Count++;
            if (Pop_Index == High_Index)
                Pop_Index = 0;
            else
                Pop_Index++;
            List[Pop_Index] = NULL;//已经pop的元素清空，放到这里防止编译器跟Pop_Count++;语句优化成序列颠倒
        }
        return result;
    }

qsc555

hy036630 发表于 2011-12-29 17:39
回复 76# qsc555

我觉得pop出来的数量做统计并不是真正的吞吐量，把你的统计（1个测试线程，或8个线程，或8个进程）看成一个统计系统A，对这个A来说，每秒处理从A外部进来的流数据量（events)，才是你要的处理能力吧？你从这个统计概念再比较8个线程和8个进程看看。
从我在上面理解的吞吐量来说，要提高吞吐量，把8个线程改成每个线程做所有原来8个线程分别要做的事，然后这8个线程都接收A系统外部来的流数据，最后汇总写到文件的时候再计算各个统计量的总和；

jetking

看完整个帖子，学习一下楼主的并行处理方式。留个脚印
流水线流的是指针，而不是处理过程，处理过程还是并发的。
线程不好进程好，从楼主自己的结论看，是处理过程的问题。

hy036630

qsc555 发表于 2011-12-30 09:07
template
class RingQueue {
public:

编译器优化的问题我还真没考虑过，借你的思路正好可以学习一下，呵呵。

zylthinking

qsc555 发表于 2011-12-30 09:07
T Pop() {
        T result = NULL;
        if (size() > 0) {//环形队列不为空
            result = List[Pop_Index];
            Pop_Count++;
            if (Pop_Index == High_Index)
                Pop_Index = 0;
            else
                Pop_Index++;
            List[Pop_Index] = NULL;//已经pop的元素清空，放到这里防止编译器跟Pop_Count++;语句优化成序列颠倒
        }
        return result;
    }

真能防止编译器乱序吗？