我是Opencl编程的新手.为了更好地学习opencl,花了一些时间阅读一些教程后,我开始开发一个简单的模式匹配内核函数.但我有些疑惑:
首先,我在内核函数中声明了全局变量.这是否意味着每个工作项共享每个变量的单个副本？
其次,我如何使用标准C库,尤其是 "string.h中".
__kernel void matchPatterns_V1(__global char *strings, __global char *patterns, __global int *matchCount,
int strCount, int strLength, int patCount, int patLength) {
int id = get_global_id(0);
int rowIndex = id*strLength;
int i, matches = 0;
__global char *pos = strings;
__global char *temp = strings;
__global char *pat = patterns;
for(i = 0; i < patCount; i++)
{
temp = &strings[rowIndex];
pat = &patterns[i*patLength];
while(pos != '\0') {
pos = StrStr(temp, pat);
if(pos != '\0') {
matches++;
temp …我有这样的程序.
create or replace
Procedure PROCEDURE_NAME
begin
Insert Instructions
Insert Instructions
Insert Instructions
Some Instructions
Some Instructions
Some Instructions
end;
以上是可以并行执行的指令块,没有任何冲突.如何在Oracle Procedure中定义并行执行它们？
我可以为它们制作不同的程序但是在这个程序中寻找最小的修改,我相信在SQL中调用并行指令是可能的.
我发现openmp不支持while循环(或者至少不太喜欢它们).而且也不喜欢'!='运算符.
我有这段代码.
int count = 1;
#pragma omp parallel for
while ( fgets(buff, BUFF_SIZE, f) != NULL )
{
len = strlen(buff);
int sequence_counter = segment_read(buff,len,count);
if (sequence_counter == 1)
{
count_of_reads++;
printf("\n Total No. of reads: %d \n",count_of_reads);
}
count++;
}
关于如何管理这个的任何线索？我在某处读到(包括stackoverflow的另一篇文章)我可以使用管道.那是什么 ？以及如何实施它？
我有两个线程使用两个不同的功能.第一个从头到尾搜索,第二个从头到尾搜索.
现在我正在使用Thread.Sleep(10)同步,但它需要花费太多时间,并且在这种情况下无法进行测试.
知道如何同步两个具有不同功能的线程？
在scala中想象你有一个很长的列表,你映射一个函数,对每个元素进行独立的操作:
val myList = List(....)
def fct(...) = {...}
myList.map(elem => fct(elem))
由于fct只使用val和不可变操作,因此可以很容易地并行化
myList.par.map(elem => fct(elem))
用for:
for(elem <- myList) {
fct(elem)
}
我的问题是如何在命令中有一个进度条,显示我们在列表中的级别.我想到了类似的东西:
var i = o
在循环之前和内部
i += 1
print(i + (" "*100) + "\r")
但这会破坏并行化的可能性.
我有一个包含100行文本的文件.
paulk@node013:test_parallel$ for i in {1..100}; do echo "trash" >> infile.txt; done
我想要几个进程并行读取此文件.
#!/usr/bin/env python
import multiprocessing
def f( in_file, out_file ):
for row in in_file:
print >> out_file, row.strip()
# out_file.seek( 0 ) # interesting line
return
f1 = open( 'infile.txt' )
f2 = open( 'infile.txt' )
g1 = open( 'outfile1.txt', 'w' )
g2 = open( 'outfile2.txt', 'w' )
p1 = multiprocessing.Process( target=f, args=( f1, g1, ) )
p1.start()
p2 = multiprocessing.Process( target=f, args=( f2, g2, ) )
p2.start() …我遇到的问题似乎与任务创建有关.在使用循环填充任务数组并在单独的循环中启动它之后,我的结果虽然一致,但却是错误的.但是,如果我单独填充数组,在循环内启动每个任务,一切都很好.任何人都可以给我一些建议吗？
例如,这是有问题的:
int c = 1;
for (int i = 1; i <= 4; i++)
{
taskArray[i-1] = new Task(() => calculateRows(c, true));
c = c + 2;
}
foreach (Task t in taskArray) t.Start();
但这很好用:
taskArray[0] = new Task(() => calculateRows(1, true));
taskArray[1] = new Task(() => calculateRows(3, true));
taskArray[2] = new Task(() => calculateRows(5, true));
taskArray[3] = new Task(() => calculateRows(7, true));
foreach (Task t in taskArray) t.Start();
我有以下代码片段,它枚举了某些xml的元素(从svn log --xml ...进程的输出中读取),然后为每个xml元素运行一个长时间运行的方法.
var proc = Process.Start(svnProcInfo);
var xml = XDocument.Load(proc.StandardOutput);
var xElements = xml.Descendants("path")
.ToObservable()
//.SubscribeOn(ThreadPoolScheduler.Instance)
.Select(descendant => return LongRunning(descendant));
xElements
//.SubscribeOn(NewThreadScheduler.Default)
.Subscribe(result => Console.WriteLine(result);
Console.ReadKey();
该LongRunning方法并不重要,但在其中我记录了它运行的线程.让我们假设它运行一整秒.
我的问题是,取消评论任何SubscribeOn()一行都没有任何效果.调用LongRunning是顺序的,每隔一秒发生一次,在同一个线程上(尽管与主(初始)线程不同).
这是一个控制台应用程序.
我是Rx的新手.我错过了什么？
编辑:
在尝试了Lee Campbell的回答之后,我注意到了另一个问题.
Console.Error.WriteLine("Main thread " + Thread.CurrentThread.ManagedThreadId);
var xElements = xml.Descendants("path").ToObservable()
//.ObserveOn(Scheduler.CurrentThread)
.SelectMany(descendant =>
Observable.Start(()=>LongRunning(descendant),NewThreadScheduler.Default))
.Subscribe(result => Console.WriteLine(
"Result on: " + Thread.CurrentThread.ManagedThreadId));
[...]
string LongRunning(XElement el)
{
Console.WriteLine("Execute on: Thread " + Thread.CurrentThread.ManagedThreadId);
DoWork();
Console.WriteLine("Finished on Thread " …我有代码看起来像这样:
Parallel.Foreach(ItemSource(),(item)=>DoSomething(item));
ItemSource() 产生无限的物品流.
我希望在满足某些条件后退出循环,而我宁愿不在DoSomething中抛出异常(我认为这种方法是一种糟糕的编程风格).
理想情况下,会有像cancelToken这样的东西.我会在一个或多个线程中调用cancellationToken.Activate(),之后parallel.foreach将停止创建新线程,并且在最后一个线程退出后,该函数将返回.
这可以用于使用Parallel.ForEach在c#中进行,还是应该使用线程insteag？
更新 以下是微软建议我这样做的方式:
try
{
Parallel.ForEach(nums, po, (num) =>
{
double d = Math.Sqrt(num);
Console.WriteLine("{0} on {1}", d, Thread.CurrentThread.ManagedThreadId);
po.CancellationToken.ThrowIfCancellationRequested();
});
}
catch (OperationCanceledException e)
{
Console.WriteLine(e.Message);
}
我不喜欢这种方法,因为它涉及在委托中抛出异常.
这是我的代码的大纲:
#pragma omp parallel default(shared)
{
for(i; i<lim; i++)
do_work();
}
过了一会儿:
do_work(){
foo();
bar();
}
foo(){
#pragma omp for //etc
for(i;i<l;i++) //your typical loop
}
bar(){ //here's the interesting part
int i;
int result;
#pragma omp for reduction(+:result) private(i)
for(i=0; i<lim; i++)
result++;
}
编译时我收到以下错误:
减少变量'result'在外部上下文中是私有的
这不应该发生,因为根据IBM编译器文档的reduction条款
使用指定的运算符对列表中的所有标量变量执行减少.列表中的减少变量用逗号分隔.
为每个线程创建列表中每个变量的私有副本.在语句块的末尾,缩减变量的所有私有副本的最终值以适合于操作符的方式组合,并且结果被放回到共享缩减变量的原始值中.
减少条款中指定的变量:
- 必须是适合操作员的类型.
- 必须在封闭的上下文中共享.
- 不能是const限定的.
- 不能有指针类型.
强调补充说.由于外部并行区域应该处理所有变量shared,这意味着一旦发现它的减少就result应该转换为private.至少虽然它不应该private在外部范围内考虑,因为外部范围已明确告知每个变量shared.这是我困惑的根源.
当然我使用的是GCC而不是IBM编译器,但这种情况有区别吗？
所以我想我的问题是:为什么OpenMP会处理减少变量.作为私有变量,它之前被声明为在外部上下文中共享？
我只有减少这个问题,其他一切都按预期工作(特别是当有一个例子完全相同的事情).