标签: multiprocessor

我想使用Gradle为4种不同的Android CPU处理器架构(armeabi armeabi-v7a x86 mips)构建4个独立的apks.

我在libs文件夹中为4个CPU架构构建了本机OpenCV库.

libs
    -armeabi
    -armeabi-v7a
    -x86
    -mips

我想每个apk只包含对应正确CPU架构的OpenCV库.

当前的构建脚本如下:

apply plugin: 'android'

dependencies {
    compile fileTree(dir: 'libs', include: '*.jar')
    compile project(':workspace:OpenCV4Android:sdk:java')
}

android {
    compileSdkVersion 11
    buildToolsVersion "18.1.0"

    sourceSets {
        main {
            manifest.srcFile 'AndroidManifest.xml'
            java.srcDirs = ['src']
            resources.srcDirs = ['src']
            aidl.srcDirs = ['src']
            renderscript.srcDirs = ['src']
            res.srcDirs = ['res']
            assets.srcDirs = ['assets']
        }

        // Move the tests to tests/java, tests/res, etc...
        instrumentTest.setRoot('tests')

        debug.setRoot('build-types/debug')
        release.setRoot('build-types/release')

        flavorGroups "abi", "version"
        productFlavors {
            x86 {
                flavorGroup "abi"
            } …

为什么我能找到很多关于"工作窃取"的信息,而没有关于"工作耸肩"的信息作为动态负载均衡策略？

通过"工作耸肩",我的意思是将多余的工作从繁忙的处理器推到负载较小的邻居,而不是让闲置的处理器从繁忙的邻居那里拉工作("偷工作").

我认为两种策略的一般可扩展性应该相同.但是我认为,就延迟和功耗而言,在确实有工作要做的时候唤醒空闲处理器,而不是让所有空闲处理器周期性地轮询所有邻居以进行可能的工作,它会更有效率.

无论如何,一个快速谷歌没有出现在"工作耸肩"或类似标题下的任何东西,所以任何指向现有技术的指针和这个策略的行话将是受欢迎的.

澄清

我实际上设想工作提交处理器(可能是或可能不是目标处理器)负责查看首选目标处理器的直接位置(基于数据/代码位置)以决定是否应该给予近邻相反,因为他们没有那么多的工作要做.

我不认为决策逻辑在这里需要的不仅仅是对立即(通常是2到4个)邻居的估计q长度的原子读数.我不认为这种情况不会超过盗贼从他们的邻居那里进行民意调查和偷窃所暗示的.(我在两种策略中都假设"无锁,无等待"队列).

解析度

似乎我的意思(但只是部分描述!)作为"工作耸肩"策略是在"正常"的前期调度策略领域,恰好是关于处理器,缓存和内存忠诚以及可扩展的.

我发现很多参考文献都在搜索这些术语,其中一些看起来非常可靠.当我发现一个最符合(或拆除!)逻辑时,我会用我的"工作耸肩"的定义发表参考文献.

我有一个Linux的Python程序几乎看起来像这样:

import os
import time

process = os.popen("top").readlines()

time.sleep(1)

os.popen("killall top")

print process

该程序挂起在这一行:

process = os.popen("top").readlines()

这种情况发生在保持更新输出的工具中,如"Top"

我最好的考验:

import os
import time
import subprocess

process = subprocess.Popen('top')

time.sleep(2)

os.popen("killall top")

print process

它比第一个(它被砍掉)效果更好,但它返回:

<subprocess.Popen object at 0x97a50cc>

第二次试验:

import os
import time
import subprocess

process = subprocess.Popen('top').readlines()

time.sleep(2)

os.popen("killall top")

print process

和第一个一样.它由于"readlines()"而被绞死

它的返回应该是这样的:

top - 05:31:15 up 12:12,  5 users,  load average: 0.25, 0.14, 0.11
Tasks: 174 total,   2 running, 172 sleeping,   0 stopped,   0 zombie
Cpu(s):  9.3%us, …

好的,所以我正在阅读有关同步的内容,并且我阅读了各种算法,例如自旋锁,信号量和互斥锁,以避免竞争条件.

但是,当多个进程完全同时访问数据时,这些算法无法阻止SMP中的竞争条件.

例如,假设处理器A中的线程1运行锁定(mutex1); 退出(1000); 解锁(mutex1);

处理器B中的线程2运行锁定(mutex1); 存款(1000); 存款(1000); 解锁(mutex1);

当两个线程在相同时间运行时,两个线程将同时处于临界区.

唯一的解决方案(应该是硬件级别)将使每个处理器彼此略微偏离,但它会破坏并行性的目的.

是否有任何硬件级别支持以避免多个处理器尝试在同一时间获取锁定的情况？

(这不是原子性问题,而是精确并行问题,我想知道SMP如何处理它).

我主要来自c ++背景,但我认为这个问题适用于任何语言的线程.这是场景:

1. 我们有两个线程(ThreadA和ThreadB),共享内存中有一个值x

2. 假设通过互斥锁(或其他合适的同步控制)适当地控制对x的访问

3. 如果线程碰巧在不同的处理器上运行,如果ThreadA执行写操作会发生什么,但是它的处理器将结果放在其L2缓存中而不是主内存中？然后,如果ThreadB尝试读取该值,它不仅会查看自己的L1/L2缓存/主内存,然后使用旧的值吗？

如果不是这样,那么这个问题是如何管理的？

如果是这样的话,那么可以采取什么措施呢？

我们可以在单个cpu上交替使用"并行编码"和"多线程编码"吗？

我在这两方面都没有多少经验,但我想把我的编码风格转移到上面的任何一个.

正如我现在发现的那样,许多单一应用程序已经过时,这对于未来的软件产业来说会更好吗？

我发现了一个测量功能性能的好问题,答案建议使用秒表,如下所示

Stopwatch sw = new Stopwatch();
sw.Start();
//DoWork
sw.Stop();
//take sw.Elapsed

但如果您在多处理器机器下运行,这是否有效？线程可以切换到另一个处理器,可以吗？同样的事情也应该在Enviroment.TickCount中.如果答案是肯定的,我应该将我的代码包装在BeginThreadAffinity中,如下所示

Thread.BeginThreadAffinity();
Stopwatch sw = new Stopwatch();
sw.Start();
//DoWork
sw.Stop();
//take sw.Elapsed
Thread.EndThreadAffinity();

PS

切换可以在线程级别上发生,而不仅仅是处理器级别,例如,如果函数在另一个线程中运行,那么系统可以将其切换到另一个处理器,如果发生这种情况,秒表在切换后是否有效？

我不是仅使用秒表进行性能测量,而是使用Thread.Sleep模拟定时器功能(以防止呼叫重叠)

大家好,这个问题可能看起来很奇怪,但我正在使用Haptek People Putty播放器作为我的C#应用​​程序,我看到有人在论坛上说它对多核处理器效果不佳.我的应用程序在我的Core 2 Duo笔记本电脑上运行良好,但是当我尝试在四核桌面上运行它时,它很多.我正在考虑为自己调查这个问题,在这种情况下,我必须强制我的应用程序在单个核心上运行.这可能在C#中吗？谢谢!

嗨,我有一个简单的脚本,它接受一个文件,并在其上运行另一个Perl脚本.该脚本对当前文件夹中的每个图片文件执行此操作.这是在一台配备2个四核Xeon处理器,16GB内存,运行RedHat Linux的机器上运行的.

第一个脚本work.pl基本上调用magicplate.pl传递一些参数和magicplate.pl文件的名称来处理.Magic Plate需要大约一分钟来处理每个图像.因为work.pl正在执行相同的功能超过100次,并且因为系统有多个处理器和核心,所以我正在考虑将任务拆分,以便它可以并行运行多次.如有必要,我可以将图像分割到不同的文件夹.任何帮助都会很棒.谢谢

这是我到目前为止:

use strict;
use warnings;


my @initialImages = <*>;

foreach my $file (@initialImages) {

    if($file =~ /.png/){
        print "processing $file...\n";
        my @tmp=split(/\./,$file);
        my $name="";
        for(my $i=0;$i<(@tmp-1);$i++) {
            if($name eq "") { $name = $tmp[$i]; } else { $name=$name.".".$tmp[$i];}
        }

        my $exten=$tmp[(@tmp-1)];
        my $orig=$name.".".$exten;

        system("perl magicPlate.pl -i ".$orig." -min 4 -max 160 -d 1");
     }
}       

对于单处理器，锁定算法非常简单。

Lock(threadID) {
  Disable Interrupts
  If lock is already owned by same thread{
    Restore Interrupts
    return
  }
  if lock is free {
    make lock busy
    set current thread as the owner of the lock
  }
  else {
     add threadID to the lock queue.
  }
  Restore Interrupts
  return
}

但是我们如何在多处理器/多核系统中实现这段代码。如果 2 个内核/进程尝试为不同的进程提供相同的锁怎么办。