小编Igo*_*lin的帖子

我有一个ListBox,它绑定到LogMessages的ObservableCollection.

public ObservableCollection<LogMessage> LogMessages { get; set; }
public LogMessageData()
{
    this.LogMessages = new ObservableCollection<LogMessage>();
}

每条消息都有两个参数:

public class LogMessage
{
    public string Msg { get; set; }
    public int Severity { get; set; }
    //code cut...
}

列表框是越来越充满了这些项目,我需要的颜色代码(改变背景颜色的一个ListBoxItem)列表取决于严重性一个的LogMessage项的参数.

这是我现在在XAML中显示日志的用户控件:

    <UserControl.Resources>
    <AlternationConverter x:Key="BackgroundSeverityConverter">
        <SolidColorBrush>Green</SolidColorBrush>
        <SolidColorBrush>Yellow</SolidColorBrush>
        <SolidColorBrush>Red</SolidColorBrush>
    </AlternationConverter>
    <Style x:Key="BindingAlternation" TargetType="{x:Type ListBoxItem}">
        <Setter Property="Background" 
                Value="{Binding RelativeSource={RelativeSource TemplatedParent}, 
                Path=Severity, 
                Converter={StaticResource BackgroundSeverityConverter}}"/>
    </Style>
    <DataTemplate x:Key="LogDataTemplate">
        <TextBlock x:Name="logItemTextBlock" Width="Auto" Height="Auto" 
        Text="{Binding Msg}"/>
    </DataTemplate>
</UserControl.Resources>

和一个实际的ListBox:

<ListBox …

我们正在尝试了解Windows CPU Scheduler如何工作以优化我们的应用程序,以实现最大可能的基础架构/实际工作比率.在xperf中有一些我们不理解的东西,并且想要让社区了解真正发生的事情.当我们得到一些服务器"缓慢"或"无响应"的报告时,我们最初开始调查这些问题.

背景资料

我们有一台运行我们的中间件基础架构的Windows 2012 R2 Server,其规格如下.

我们发现有30%的CPU浪费在内核上,所以我们开始深入挖掘.

上面的服务器运行"主机"~500个进程(作为windows服务),这些"主机"进程中的每一个都有一个内部while循环,延迟〜250毫秒(yuck!),并且每个"主机"进程可能有〜 1..2执行实际工作的"子"进程.

虽然在迭代之间具有250毫秒延迟的无限循环,但"主机"应用程序执行的实际有用工作可能仅每10..15秒出现一次.所以浪费了很多周期来进行不必要的循环.

我们知道,"主机"应用程序的设计至少可以说是次优的,适用于我们的场景.应用程序将更改为基于事件的模型,该模型不需要循环,因此我们期望CPU利用率图中的"内核"时间显着减少.

然而,当我们调查这个问题时,我们已经做了一些xperf分析,它提出了几个关于Windows CPU Scheduler的一般性问题,我们无法找到任何明确/简明的解释.

我们不明白的是什么

以下是其中一个xperf会话的屏幕截图.

您可以从"CPU使用率(精确度)"中看到

• 有15毫秒的时间片,其中大部分未充分利用.这些切片的利用率约为35-40%.因此,我认为这反过来意味着CPU大约在35%到40%的时间内被利用,但系统的性能(假设通过系统周围的随意修改可观察到)实际上是缓慢的.

• 有了这个,我们就有了这个"神秘的"30%内核时间成本,由任务管理器CPU利用率图判断.

• 有些CPU明显用于整个15 ms及更高的分片.

问题

就多处理器系统上的Windows CPU调度而言:

• 什么导致30%的内核成本？上下文切换？别的什么？在编写应用程序以降低此成本时应该考虑哪些因素？甚至 - 以最小的基础设施成本实现完美的利用(在多处理器系统上,其中进程数高于核心数)
  • 这些15毫秒切片是什么？
  • 为什么CPU利用率在这些切片中存在差距？

我们有一个.NET后台处理应用程序(控制台应用程序),它执行一些任意工作负载(基本上内部用户提供实现"执行"接口的.NET DLL).然后,后台处理应用程序通过反射加载dll并执行它.

其中一个提供的DLL显然有一个COM对象,它没有正确处理(可能).

由于处理时间很长,并且我们在主线程上创建了COM对象而没有正确处理,这会导致终结器线程被阻塞,这会导致进程累积大量未释放的句柄(它可能会上升)到几十万)

我已经尝试使用WinDbg调试该进程的转储,我清楚地看到终结器线程在COM调用的主线程上被阻止.

首先我们看一下终结器线程中的非托管堆栈(我假设尝试与另一个线程通信以完成COM对象):

0:002> kb
 # ChildEBP RetAddr  Args to Child              
00 0372eec0 74a92cc7 00000968 00000000 00000000 ntdll!NtWaitForSingleObject+0xc
01 0372ef34 74a92c02 00000968 ffffffff 00000000 KERNELBASE!WaitForSingleObjectEx+0x99
02 0372ef48 74dd9839 00000968 ffffffff 010846e4 KERNELBASE!WaitForSingleObject+0x12
03 (Inline) -------- -------- -------- -------- combase!MTAThreadWaitForCall+0x43 [d:\blue\com\combase\dcomrem\channelb.cxx @ 5657]
04 0372ef78 74e7d524 01083ef0 0111a198 0372f1e4 combase!MTAThreadDispatchCrossApartmentCall+0x1ed [d:\blue\com\combase\dcomrem\chancont.cxx @ 193]
05 (Inline) -------- -------- -------- -------- combase!CRpcChannelBuffer::SwitchAptAndDispatchCall+0x33a2 [d:\blue\com\combase\dcomrem\channelb.cxx @ 5052]
06 0372f0cc 74d5caea 010846e4 0372f1e4 0372f1ac combase!CRpcChannelBuffer::SendReceive2+0x62d [d:\blue\com\combase\dcomrem\channelb.cxx @ 4796]
07 (Inline) -------- -------- -------- …

我有这个非常简单的代码,很少抛出"System.ApplicationException:从非同步的代码块调用对象同步方法." 当调用ReleaseMutex()时.

我在逻辑上分析了方法的流程,并且无法理解这种情况如何/为何会发生.根据我的理解,在这种情况下保证互斥锁的所有权:

    readonly string mutexKey;

    public Logger(string dbServer, string dbName)
    {
        this.mutexKey = ServiceManagerHelper.GetServiceName(dbServer, dbName);
    }

    private void Log(LogType type, string message, Exception ex)
    {
        using (var mutex = new Mutex(false, mutexKey))
        {
            bool acquiredMutex;
            try
            {
                acquiredMutex = mutex.WaitOne(TimeSpan.FromSeconds(5));
            }
            catch (AbandonedMutexException)
            {
                acquiredMutex = true;
            }

            if (acquiredMutex)
            {
                try
                {

                    // some application code here

                }
                finally
                {
                    mutex.ReleaseMutex();
                }
            }
        }
    }

我有一个基类结构和几个继承的类.基类应该是纯虚拟类,它应该防止实例化.可以实例化继承的类.代码示例如下:

class BaseClass
{
public:
    BaseClass(void);
    virtual ~BaseClass(void) = 0;
};

class InheritedClass : public BaseClass
{
public:
    InheritedClass1(void);
    ~InheritedClass1(void);
};

class DifferentInheritedClass : public BaseClass
{
public:
    DifferentInheritedClass(void);
    ~DifferentInheritedClass(void);
};

我想阻止以下操作发生:

InheritedClass *inherited1 = new InheritedClass();

DifferentInheritedClass *inherited2 = new DifferentInheritedClass ();

BaseClass *base_1 = inherited1;
BaseClass *base_2 = inherited2;

*base_1 = *base_2;