标签: processing-efficiency

用C语言获取当前时间/日期/日/年的最有效方法是什么？由于我必须多次执行,我需要一种真正有效的方法.我在freeBSD上.

提前致谢.

我正在寻找实现一个生产者多个消费者多线程应用程序的最佳方案.目前我正在使用一个队列来共享缓冲区,但它比一个生产者一个消费者的情况要慢得多.我打算这样做:

Queue<item>[] buffs = new Queue<item>[N];
object[] _locks = new object[N];
static void Produce()
{
    int curIndex = 0;
    while(true)
    {
        // Produce item;
        lock(_locks[curIndex])
        {
            buffs[curIndex].Enqueue(curItem);
            Monitor.Pulse(_locks[curIndex]);
        }
        curIndex = (curIndex+1)%N;
    }
}

static void Consume(int myIndex)
{
    item curItem;
    while(true)
    {
        lock(_locks[myIndex])
        {
            while(buffs[myIndex].Count == 0)
                Monitor.Wait(_locks[myIndex]);
            curItem = buffs[myIndex].Dequeue();
        }
        // Consume item;
    }
}

static void main()
{
    int N = 100;
    Thread[] consumers = new Thread[N];
    for(int i = 0; i < N; i++)
    { …

关于如何在MATLAB中创建循环缓冲区,这里有一些好的帖子(比如这篇).然而,通过查看它们,我不相信它们适合我的应用程序,因为我所寻求的是MATLAB中的循环缓冲解决方案,它不涉及任何旧数据的复制.

举一个简单的例子,我们说我一次处理50个样本,每次迭代读取10个样本.我将首先完成5次迭代,填充我的缓冲区,最后处理我的50个样本.所以我的缓冲区将是

[B1 B2 B3 B4 B5]

,其中每个'B'是10个样本的块.

现在,我在接下来的10个样本中读到,称之为B6.我希望我的缓冲区现在看起来像:

[B2 B3 B4 B5 B6]

问题就是这样 - 我不想每次都复制旧数据,B2,B3,B4,B5,因为它在时间上变得昂贵.(我有非常大的数据集).

我想知道是否有办法在不复制"旧"数据的情况下执行此操作.谢谢.

特殊字符将在标签上用红色突出显示，因此我在下面编写了功能不错的函数，但我想确认一下，还有其他有效的方法吗？例如

-(NSMutableAttributedString*)getAttributeText:(NSString*)string forSubstring:(NSString*)searchstring {
    NSMutableAttributedString *text = [[NSMutableAttributedString alloc] initWithString:_lblName.text];
    NSRange searchRange = NSMakeRange(0,string.length);
    for (NSInteger charIdx=0; charIdx<searchstring.length; charIdx++){
        NSString *substring = [searchstring substringWithRange:NSMakeRange(charIdx, 1)];
        NSRange foundRange;
        searchRange.location = 0;
        while (searchRange.location < string.length) {
            searchRange.length = string.length-searchRange.location;
            foundRange = [string rangeOfString:substring options:1 range:searchRange];
            [text addAttribute: NSForegroundColorAttributeName value: [UIColor redColor] range:foundRange];
            if (foundRange.location != NSNotFound) {
                searchRange.location = foundRange.location+foundRange.length;
            } else {
                // no more substring to find
                break;
            }
        }
    }
    return text;
}

下面是我如何使用它的代码，以及结果

NSString *string = @"James …

目前，我正在使用该SetPixel()方法来更改位图中每个像素的颜色。这对于小尺寸的小图像效果很好，但是当我在大图像上测试它时，它确实需要一段时间。

我以前没有在 VB.Net 中处理过图像，所以我可能只是忽略了一些明显的东西。我这样做是为了制作一个将图像转换为灰度的程序。这会产生正确的结果，但速度较低，并且在此期间 UI 会冻结，因此我热衷于最大限度地提高转换速度。

这是我目前的代码：

Dim tmpImg As New Bitmap(img) '"img" is a reference to the original image 
For x As Integer = 0 To tmpImg.Width - 1
    For y As Integer = 0 To tmpImg.Height - 1
        Dim clr As Byte
        With tmpImg.GetPixel(x, y)
            clr = ConvertToGrey(.R, .G, .B)
        End With
        tmpImg.SetPixel(x, y, Color.FromArgb(clr, clr, clr))
    Next
Next

Private Function ConvertToGrey(ByVal R As Byte, ByVal G As Byte, ByVal B As Byte) As Byte
    Return …

我想知道在操作方面,交换整数的方式最有效的是c ++,为什么？是这样的:

int a =..., b = ...;
a = a + b;
b = a - b;
a = a - b;

比使用临时更有效？还有其他更有效的方法吗？(不要求其他方式交换整数),为什么它们会更有效率？

只是好奇哪个在 swift 中更有效/更好：

• 创建三个临时常量（使用 let）并使用这些常量定义其他变量
• 创建一个临时变量（使用 var）并使用该变量保存三个不同的值，然后这些值将用于定义其他变量

这也许可以通过一个例子更好地解释：

var one = Object()
var two = Object()
var three = Object()

func firstFunction() {
    let tempVar1 = //calculation1
    one = tempVar1

    let tempVar2 = //calculation2
    two = tempVar2

    let tempVar3 = //calculation3
    three = tempVar3

}

func seconFunction() {
    var tempVar = //calculation1
        one = tempVar

    tempVar = //calculation2
        two = tempVar

    tempVar = //calculation3
        three = tempVar

}

这两个函数哪个更有效？感谢您的时间！

例如,如果我有:

if(x < 2*0.025) { ... }

是否2*0.025得到计算每一次？或者是否0.05取代,以便乘法操作不必每次都运行？

换句话说,使用它0.05而不是更有效2*0.025吗？

目前,我正在读一本研究,这是我教授在课堂上发表的指南.学习指南不是作业,只是知道在考试中会发生什么.我已经完成了除1个问题之外的所有问题,希望有人可以帮助我.

这是一个问题:假设Tserial = n和Tparallel = n/p + log2(p),其中时间以毫秒为单位,p是进程数.如果我们将p增加k倍,找到一个公式,我们需要增加多少n才能保持恒定的效率.如果我们将进程数量从8增加到16,我们应该增加多少？并行程序是否可扩展？

任何帮助理解这一点将不胜感激.

我有以下大而非常低效的循环.

P is a [2000 x 200 x 5] matrix
D is a [2000 x 200 x 5] matrix
S is a [200 x 1005] matrix
PS is a [2000 x 1000 x 5] matrix

我想计算以下循环:

for k=1:2000
   for n=1:200
      for t=1:5
          P(k,n,t) = sum(S(n,t+1:t+1000) .* PS(k,1:1000,t));
      end
   end
end

显然这是非常低效的.我尝试过parfor,但我宁愿使用矢量化解决方案.我尝试了几件事bsxfun,但也从未设法让它发挥作用.

谢谢.