OpenMP中的原子和关键有什么区别？

我可以做这个

#pragma omp atomic
g_qCount++;

但是不一样

#pragma omp critical
g_qCount++;

？

我正在尝试创建一个自旋锁的哑版.浏览网页时,我在x86中遇到了一个名为"PAUSE"的汇编指令,该指令用于向处理器提供当前在此CPU上运行自旋锁的提示.英特尔手册和其他可用信息说明了这一点

在大多数情况下,处理器使用此提示来避免内存顺序违规,从而大大提高了处理器性能.因此,建议在所有自旋等待循环中放置PAUSE指令.文档还提到"等待(一些延迟)"是指令的伪实现.

上段的最后一行很直观.如果我没有成功抓住锁,我必须等待一段时间然后再抓住锁.

但是,在旋转锁定的情况下,内存顺序违规是什么意思？"内存顺序违规"是否意味着旋转锁定后指令的错误推测加载/存储？

关于堆栈溢出之前已经询问了自旋锁定问题但是内存顺序违规问题仍未得到解决(至少对于我的理解).

我正在阅读Peter B. Galvin的"操作系统概念中的关键部分问题".根据它

1)进度是:如果没有进程在其关键部分执行,并且某些进程希望进入其关键部分,那么只有那些未在其余部分中执行的进程才能参与决定哪个进程将在下一个进入其关键部分,选择不能无限期推迟.

和

2)有界等待是:在进程请求进入其关键部分之后且在该请求被授予之前,允许其他进程进入其关键部分的次数存在约束或限制.

我不理解作者想要在两种情况下说什么.

您能否通过提供与此定义相关的适当示例来让我理解.

谢谢.

我正在编写一个程序,其中有一个由多个线程共享的对象:

• A)多个写线程写入对象(所有运行相同的函数)
• B)每5秒访问一次对象的读线程
• C)访问对象的读取线程存在用户请求

显然有必要在写入时锁定对象,因为我们不希望多个线程同时写入对象.

我的问题是:

1. 在读取对象时是否还需要锁定对象？
2. 我是否认为如果我们只是在写作时锁定对象,那么关键部分就足够了; 但是如果我们在读取或写入时锁定对象,则需要互斥锁？

我问这个问题,因为在Microsoft Office中,Word的两个实例不可能以读/写访问模式访问文档; 但是当文档以读/写模式打开时,可以打开另一个Word实例以只读模式访问文档.线程中是否也适用相同的逻辑？

我正在调试一个多线程应用程序,并找到了内部结构CRITICAL_SECTION.我发现LockSemaphoreCRITICAL_SECTION的数据成员很有趣.

它看起来像是LockSemaphore一个自动重置事件(顾名思义不是信号量),并且当第一次线程等待Critcal Section某个其他线程锁定时,操作系统会静默创建此事件.

现在,我想知道关键部分总是更快吗？Event是一个内核对象,每个Critical部分对象都与事件对象相关联,那么Critical Section与其他内核对象(如Mutex)相比,如何更快？此外,内部事件对象如何实际影响Critical部分的性能？

这是结构CRITICAL_SECTION:

struct RTL_CRITICAL_SECTION
{
    PRTL_CRITICAL_SECTION_DEBUG DebugInfo;
    LONG LockCount;
    LONG RecursionCount;
    HANDLE OwningThread;
    HANDLE LockSemaphore;
    ULONG_PTR SpinCount;
};

我有两个C++代码在两个不同的内核上运行.它们都写入同一个文件.

如何使用OpenMP并确保没有崩溃？

那里有更快的那种TMultiReadExclusiveWriteSynchronizer吗？FastCode也许吧？

从Windows Vista开始,Microsoft添加了Slim Reader/Writer锁.它的性能比Delphi 好得多TMultiReadExclusiveWriteSynchronizer.不幸的是,它只存在于Windows Vista及更高版本中,这是很少有客户真正拥有的东西.

据推测,Slim Reader/Writer lock在本机中使用的概念可以在本机Delphi代码中重做 - 但有人做过吗？

我有一种情况,即获取和释放锁定TMultiReadExclusiveWriteSynchronizer(即使没有争用 - 单个线程),导致100%的开销(操作时间加倍).我可以在没有锁定的情况下运行,但是我的类不再是线程安全的.

有更快的TMultiReadExclusiveWriteSynchronizer吗？

注意:如果我使用TCriticalSectioni,只会遭受2%的性能损失(尽管已知关键部分在获取成功时很快,即它是单线程并且没有争用).CS的缺点是我失去了" 多个读者 "的能力.

测量

使用TMultiReadExclusiveWriteSynchronizer相当长的时间在内部BeginRead和EndRead:

然后移植代码以使用Window自己的SlimReaderWriter Lock(其中一些代码重写,因为它不支持递归锁定),并分析了resutls:

• TMultiReadExclusiveWriteSynchronizer:每次迭代
  10,698 ns 10,697,772,613 ns,迭代1,000,000次

• SRWLock:每次迭代
  8,802 ns,8,801,678,339 ns,迭代1,000,000次

• Omni Reader-Writer lock:每次迭代8,941 ns,
  8,940,552,487 ns,迭代1,000,000次

使用SRWLocks(又名Omni的旋转锁)时,性能提高了17%.

现在,我不能永久地切换代码以使用Windows Vista SRWLocks,因为有些客户仍然在Windows XP上.

Slim锁只是小心使用InterlockedCompareExchange功能; 但比我能成功使用更加小心.我 …

这来自MSDN:lock关键字确保一个线程不进入代码的关键部分,而另一个线程处于临界区.

难道一个关键部分必须是相同的关键部分？

或者它的意思是:lock关键字确保一个线程不会进入由代码对象保护的任何关键部分,而另一个线程处于由同一对象保护的任何关键部分.？

    class Program
{
    static void Main(string[] args)
    {
        TestDifferentCriticalSections();

        Console.ReadLine();
    }

    private static void TestDifferentCriticalSections()
    {
        Test lo = new Test();

        Thread t1 = new Thread(() =>
        {
            lo.MethodA();
        });
        t1.Start();

        Thread t2 = new Thread(() =>
        {
            lo.MethodB();
        });
        t2.Start();
    }
}

public class Test
{
    private object obj = new object();

    public Test()
    { }

    public void MethodA()
    {
        lock (obj) …

例如,这是否有效？

CRITICAL_SECTION cs;

::InitializeCriticalSection( &cs );

::EnterCriticalSection( &cs );      // First level
::EnterCriticalSection( &cs );        // Second level

/* do some stuff */

::LeaveCriticalSection( &cs );        // Second level
::LeaveCriticalSection( &cs );      // First level

::DeleteCriticalSection( &cs );

显然,我永远不会故意这样做,但是如果由于函数调用而产生这样的结果,那么"第一级"被调用来锁定对象以进行复杂(例如搜索)算法和"第二级"在该对象的访问器函数中被调用？

这些实际上是三个不同的概念还是我变得混乱？(我一直在阅读有关线程和垃圾收集的文章,并让自己感到困惑.)

"关键部分" - 我认为这可能只是您不希望多个线程同时访问的代码段的术语,即内部锁和Monitor.Enter/Exit语句？

"关键区域" - 这里没有真正的线索 - MSDN说的是"这告诉主持人该部分内的异常可能会产生更广泛的影响".并且"CLR的主机,例如Sql Server"可以选择"以不同方式"处理在关键区域内抛出的异常.不同如何？为什么？而且,最重要的是,我需要将代码标记为关键区域的真实场景？

"约束执行区" - 我在阅读垃圾收集文章中的CriticalFinalizerObject时遇到过这种情况.

我在MSDN上可以理解的是,其中一个区域内的代码在某种程度上可以保证运行(但是如何？)因此必须抛出"带外"异常.

什么是out-of-band exception？(我确实谷歌了,但它只是问我是否意味着"超出界限").

是否有任何未处理的例外？或者只是某些类型的例外？而且,最重要的是,在现实世界的情景中,我可能需要一个"受限制的执行区域"？

由于我根本不理解这些概念,我不确定这个问题除了".NET"之外还需要什么标签.