小编iam*_*iam的帖子

是否可以使用C#lambda/delegate来获取可以使用Dynamic-invoke调用的可变数量的参数？

我在这种情况下使用'params'关键字的所有尝试都失败了.

来自答案的工作代码更新:

delegate void Foo(params string[] strings);

static void Main(string[] args)                       
{
    Foo x = strings =>
    {
        foreach(string s in strings)
            Console.WriteLine(s);
    };

    //Added to make it clear how this eventually is used :)
    Delegate d = x;

    d.DynamicInvoke(new[]{new string[]{"1", "2", "3"}});
}

我试图使用lambda代替函数指针,但VS2010似乎无法转换它.我试过像这样使用std :: function它崩溃了,我不知道我这样做是否合适!

#include <windows.h>
#include <conio.h>

#include <functional>
#include <iostream>

#include <concrt.h>


void main()
{
    std::function<void(void*)> f = [](void*) -> void
    {
        std::cout << "Hello\n";
    };


    Concurrency::CurrentScheduler::ScheduleTask(f.target<void(void*)>(), 0);

    getch();
}

对我来说,编译器无法将这样的lambda转换为简单的函数指针,因为它没有捕获任何变量 - 我也不知道该怎么办.

每个lambda的类型是唯一的吗？所以我可以使用lambdas'类型作为模板参数来模拟一个模板函数,以生成一个可以被调用的独特静态函数,并希望优化出来？

更新

以下似乎工作,但它是否安全？

#include <windows.h>
#include <conio.h>

#include <iostream>

#include <concrt.h>


template<typename Signature>
struct Bind
{
    static Signature method;

    static void Call(void* parameter)
    {
        method(parameter);
    }
};


template<typename Signature>
Signature Bind<Signature>::method;


template<typename Signature>
void ScheduleTask(Signature method)
{
    Bind<Signature>::method = method;
    Concurrency::CurrentScheduler::ScheduleTask(&Bind<Signature>::Call,0);
}


void main()
{
    ScheduleTask …

我已经开始在C#中大量使用匿名委托了,我开始怀疑编译器或运行时从实际运行的代码中删除它们的效率如何,我还没有在任何地方看到过详细的内容？

是否足够聪明地内联它们并崩溃可以静态推导的递归用法？

我试图通过跳过昂贵的事件操作来提高生产者/消费者线程的情况,如果有必要,可以使用以下方法:

//cas(variable, compare, set) is atomic compare and swap
//queue is already lock free

running = false


// dd item to queue – producer thread(s)

if(cas(running, false, true))
{
  // We effectively obtained a lock on signalling the event
  add_to_queue()
  signal_event()
}
else
{
  // Most of the time if things are busy we should not be signalling the event
  add_to_queue()

  if(cas(running, false, true))
    signal_event()
}

...

// Process queue, single consumer thread

reset_event()

while(1)
{
  wait_for_auto_reset_event() // Preferably IOCP …

在为AVX256,AVX512和一天AVX1024设计前瞻性算法时,考虑到大SIMD宽度的完全通用置换的潜在实现复杂性/成本,我想知道即使在AVX512中通常保持隔离128位操作是否更好？

特别是考虑到AVX有128位单元来执行256位操作.

为此,我想知道在所有512位向量中AVX512置换类型操作之间是否存在性能差异,而在 512位向量的每个4x128位子向量中是否存在置换类型操作？

我试图找出一个合理快速的双线性过滤函数,一次只为一个过滤的样本,现在作为习惯使用内在函数的练习 - 直到SSE41是好的.

到目前为止,我有以下内容:

inline __m128i DivideBy255_8xUint16(const __m128i value)
{
    //  Blinn 16bit divide by 255 trick but across 8 packed 16bit values
    const __m128i plus128 = _mm_add_epi16(value, _mm_set1_epi16(128));
    const __m128i plus128ThenDivideBy256 = _mm_srli_epi16(plus128, 8);          //  TODO:   Should this be an arithmetic or logical shift or does it matter?
    const __m128i partial = _mm_add_epi16(plus128, plus128ThenDivideBy256);
    const __m128i result = _mm_srli_epi16(partial, 8);                          //  TODO:   Should this be an arithmetic or logical shift or does it matter?


    return result;
}


inline uint32_t …

使用.NET,TcpClient如果我BeginRead()在关联的网络流上调用异步,我仍然可以Write()在另一个线程上调用该流吗？

还是我要lock()的TcpClient代码被称为从后面BeginRead和不发送的代码？

如果我关闭了TcpClient:

client.GetStream().Close();
client.Close();

我一定要lock()上TcpClient呢？

在非 Cuda C++ 代码中，当前建议的做法是应使用通过 memcpy 的类型双关，而不是通过联合使用 UB。尽管它可能会导致调试版本中的性能问题，而且事实上我不得不多次使用 UB 根目录才能在发布版本中获得更好的性能。

Cuda 中推荐的做法是什么？它总是会不幸地在调试版本中调用 memcpy() 吗？

将 OSX/iOS 中的虚拟内存系统行为与 Windows 中的虚拟内存系统行为进行比较时，我有点困惑。Windows VirtualAlloc() 相关函数及其在保留和实际内存提交和取消提交方面的行为是相当简单的。

对于没有很好讨论的 OSX，我一直在研究 mach_vm_allocate()、mach_vm_map() 等。例如，如果我想创建一组跨平台函数来公开 Windows 和 OSX/iOS 之间的公共虚拟内存功能，我将如何管理与 Windows 相比，OSX 上的提交/取消提交之间的区别？

因为我不确定我是否理解您是否可以保留虚拟地址范围并将其作为像在 Windows 上一样的单独操作提交？根据我的理解，mach_vm_allocate() 类似于 VirtualAlloc() 和 MEM_COMMIT | MEM_RESERVE 并尝试比较哪个实际上是设计更好的机制（如果有的话）。

可能我需要更好地了解页面管理器在 OSX 中的功能。

在 Windows 上，即使您提交了一个区域，我怀疑它可能实际上并没有用物理内存支持它，直到您尝试访问它，除非当前可能有足够的内存 - 并且它只是保证在修改时支持交换文件。

在 OSX 上，我不确定如何取消提交区域但仍保留地址范围？例如，这种行为在 64 位程序中很有用（我最感兴趣的是）为具有回滚能力的竞技场/堆栈/线性分配器保留一个大的虚拟地址范围——这需要能够提交和取消提交区域的末端。在 Windows 中很明显如何产生这种行为，但在 OSX 中我不太明白如何有效地复制它。

编辑：

我刚刚发现了这个：

在 OS X 上保留内存

这与我的问题有关，但肯定 mmap() 经历了等效的 mach_vm_*() 系统调用？

编辑2：

典型的我现在发现这些：

带有 MAP_NORESERVE 的 mmap 是否保留物理内存？

如何在 Linux 中保留虚拟内存？

但它可能仍然没有弄清楚如何以我想要的方式取消提交 - 但是去谷歌更多关于 mmap() ANON 的东西 - 并可能看看我是否可以找到 OSX 的 mmap() 源代码（ …

在x64上，如果您首先在短时间内在先前未缓存的地址上写入完整缓存行的内容，然后在再次从该地址读取后不久，CPU是否可以避免必须从内存读取该地址的旧内容？

同样有效的是，先前的内存内容并不重要，因为全部高速缓存行中的数据已被完全覆盖？我可以理解，如果这是对未缓存地址的部分缓存行写入，然后是读取，则将产生必须与主内存等同步的开销。

从文档方面看，写分配，写合并和监听使我对此事有些困惑。目前，我认为x64 CPU无法做到这一点？

我相信 Windows 已经在内部使用该指令很长时间了，所以 CPU 制造商会花精力去优化吗？

当然，假设适当对齐的内存和不共享缓存线等。