小编Tay*_*lor的帖子

如何在不关闭和重新打开文档的情况下使用打开的UIDocument重命名文档文件？关闭(保存),移动和重新打开文档需要太长时间.

我有以下代码移动文件:

NSFileCoordinator* fileCoordinator = [[NSFileCoordinator alloc] initWithFilePresenter:nil];
[fileCoordinator coordinateWritingItemAtURL:oldPath
                                    options:NSFileCoordinatorWritingForMoving
                           writingItemAtURL:newPath
                                    options:NSFileCoordinatorWritingForReplacing
                                      error:&coordinatorError
                                 byAccessor:^(NSURL *newURL1, NSURL *newURL2) {
  // Rename the file.
  NSFileManager* fileManager = [NSFileManager defaultManager];
  [fileCoordinator itemAtURL:oldPath willMoveToURL:newPath];
  [fileManager moveItemAtURL:newURL1 toURL:newURL2 error:nil];
  [fileCoordinator itemAtURL:oldPath didMoveToURL:newPath];
}];

根据文档UIDocument工具presentedItemDidMoveToURL:更新它fileURL(参见https://developer.apple.com/library/ios/documentation/UIKit/Reference/UIDocument_Class/)

但是,当文档打开时调用上面的代码时,它会挂起,大概等待锁定oldPath(-[NSFileCoordinator(NSPrivate) _blockOnAccessClaim:]).如果没有生活,工作正常UIDocument.

相关的,最佳答案建议关闭并重新打开UIDocument:将UIDocument移动到文件系统上的新位置的正确方法是什么？

我试图更好地理解无锁编程：

假设我们在数据竞争中有两个线程：

// Thread 1
x = 1

// Thread 2
x = 2

有没有一种无锁的方式，第三个线程可以在无法读取 x 的情况下知道竞争的结果？

假设线程3消费了一个无锁队列，代码为：

// Thread 1
x = 1
queue.push(1)

// Thread 2
x = 2
queue.push(2)

然后可以将操作排序为：

x = 1
x = 2
queue.push(1)
queue.push(2)

或者

x = 1
x = 2
queue.push(2)
queue.push(1)

因此，只有一个无锁队列不足以让线程 3 在比赛后知道 x 的值。

我有一个Windows/C++应用程序(使用JUCE),我想在应用程序崩溃时将堆栈跟踪转储到文件中.在我的初始化代码中,我得到了:

signal(SIGABRT, abortHandler);
signal(SIGSEGV, abortHandler);
signal(SIGILL, abortHandler);
signal(SIGFPE, abortHandler);

然后我的处理程序看起来像:

void abortHandler(int signum)
{
    juce::File log("stacktrace.txt");

    log.appendText(juce::SystemStats::getStackBacktrace());

    exit(signum);
}

但是,生成的堆栈跟踪不是发生崩溃的线程:

0: AudulusDebug32: juce::SystemStats::getStackBacktrace + 0x7f
1: AudulusDebug32: abortHandler + 0x61
2: AudulusDebug32: _XcptFilter + 0x1e3
3: AudulusDebug32: __tmainCRTStartup + 0x15f
4: AudulusDebug32: WinMainCRTStartup + 0xd
5: BaseThreadInitThunk + 0xe
6: RtlInitializeExceptionChain + 0x84
7: RtlInitializeExceptionChain + 0x5a

在内部,getStackBacktrace执行以下操作:

    HANDLE process = GetCurrentProcess();
    SymInitialize (process, nullptr, TRUE);

    void* stack[128];
    int frames = (int) CaptureStackBackTrace (0, numElementsInArray (stack), stack, nullptr); …

我正在使用Metal计算内核生成网格数据(目前是三角形汤).

是否可以有效地(没有任何复制)将网格数据带入SceneKit以利用SceneKit的渲染器？网格数据会频繁更新,因此避免复制数据非常重要.三角形的数量也可以改变每个帧.

有没有办法View在布局后获取的框架？在布局放置两个视图之后，我想画一条线连接两个视图：

似乎我需要类似measureReact的东西。

使用enabled_shared_from_this时似乎有一些边缘情况.例如:

提升shared_from_this和多重继承

可以在不需要enable_shared_from_this的情况下实现shared_from_this吗？如果是这样,它可以快速制作吗？

通过 Edit Scheme -> Run -> Options -> Metal API Validation: Xcode logging: "Metal API Validation Enabled"运行我的应用程序时，很容易启用 Metal API 验证

但是对于测试呢？Edit Scheme -> Test 中没有这样的设置，当我运行测试时，验证似乎是关闭的。

我使用计算的goto实现了一个小字节码解释器（如果不熟悉，请参见此处）。

似乎可以通过在标签之间复制内存来进行简单的JITting，从而优化跳转。例如，假设我的解释器中包含以下内容：

op_inc: val++; DISPATCH();

我将其更改为：

op_inc: val++;
op_inc_end:

JITting时，我会将标签之间的内存附加到我的输出中：

memcpy(jit_code+offset, &&op_inc, &&op_inc_end - &&op_inc);

（jit_code使用标记为可执行mmap）

最后，我将使用compute goto跳转到复制的机器代码的开头：

goto *(void*)jit_code

这样行吗？我的机器代码思维模型中是否缺少某些东西可以阻止这个想法？

假设代码和数据共享相同的地址空间。我们还假设PIC。

更新资料

查看链接文章中的示例，删除后DISPATCH，我们有：

        do_inc:
            val++;
        do_dec:
            val--;
        do_mul2:
            val *= 2;
        do_div2:
            val /= 2;
        do_add7:
            val += 7;
        do_neg:
            val = -val;
        do_halt:
            return val;

生成的代码do_inc（无优化）很简单：

Ltmp0:                                  ## Block address taken
## %bb.1:
    movl    -20(%rbp), %eax
    addl    $1, %eax
    movl    %eax, -20(%rbp)

（后接do_dec …

我想知道在C ++中是否有可能创建一种像VLA（堆栈分配的，可变大小的）那样工作的类型，也可以从函数中返回它，并且不会像线性分配器那样浪费内存。

可以像这样使用：

// Fibonacci sequence
stack_array<int> fib(size_t n) {

  stack_array<int> f(n);
  f[0] = 0;
  f[1] = 1;
  for(size_t i=2;i<n;++i) {
    f[i] = f[i-1] + f[i-2];
  }

  return f;
}

这很有用，因为我发现自己std::vector通过堆分配返回可变大小的东西（通常使用）。我可能还想在不允许堆分配的实时上下文中执行此操作。例如，在音频缓冲区上进行功能风格编程。但主要是，这是一项明智的练习，以了解可能的结果。

我意识到我可以编写一个std::allocator可以进行线性分配的a，从而满足实时约束并轻松支持非平凡的类型，但这有浪费内存的缺点。我想知道我能否做得更好。

为了更具体一点，假设我们有：

thread_local arena myArena; // I don't want to have to pass this around!

std::vector<float> f() {
   return std::vector<float, arena>(64, myArena);
}

std::vector<float> g() {
   return std::vector<float, arena>(64, myArena);
}

void main() {

   {
       auto a = f();
   }

   {
       auto b = g(); …

我正在为基于文档的 macOS 应用程序编写 UI 测试。

该测试通过单击启动屏幕窗口中的按钮（非常类似于“欢迎使用 Xcode”窗口）来打开模板文档。这适用于第一次测试运行。但随后的启动因状态恢复而受挫，因为之前打开的文档覆盖了启动屏幕窗口。

运行 Xcode UI 测试时如何禁用状态恢复？

我已经在我的应用程序目标中禁用了状态恢复（“启动应用程序而不恢复状态”），效果很好。但这不会延续到测试目标，即使选中“使用运行操作的参数和环境变量”也是如此。

我还尝试在测试结束时关闭之前打开的文档，但是当我在保存对话框中单击“删除副本”时，“记录 UI 测试”不会记录任何内容。

我有以下循环：

float* s;
float* ap;
float* bp;

... // initialize s, ap, bp

for(size_t i=0;i<64;++i) {
   s[i] = ap[i]+bp[i];
}

似乎是矢量化的良好候选者。尽管我打开了优化功能，但是当我查看程序集输出时，clang（我正在使用Xcode）似乎没有向量化循环：

LBB33_1:                                ## =>This Inner Loop Header: Depth=1
    movss   (%rax,%rsi,4), %xmm0    ## xmm0 = mem[0],zero,zero,zero
    addss   (%rcx,%rsi,4), %xmm0
    movss   %xmm0, (%rdx,%rsi,4)
Ltmp353:
    incq    %rsi
Ltmp354:
    cmpq    $64, %rsi
Ltmp355:
    jne LBB33_1

如何获得clang / Xcode来向量化此简单循环？