标签: shared-memory

我正在编写一个具有共享内存的应用程序，并且正在创建具有适当"Local\"前缀的命名互斥锁。但是，每次我调用该CreateMutex函数来创建句柄时，都会得到一个NULL返回值。我什至尝试OpenMutex在那之后打电话并获得NULL回报。

该GetLastError()函数返回6，这意味着ERROR_INVALID_HANDLE。我相信这发生在第一次尝试在任何进程中创建这个命名的互斥锁时。我windows.h在包含一些 MFC 组件之后包含并且正在CMutex应用程序的其他地方使用；所以我不知道这是否有问题。我总是传递NULL和传递FALSE前两个参数，并且使用的是 Windows XP。

这是我的代码功能的摘要：

char to_name[16] = "Local\\to_1";
d_mutex_to_h = CreateMutex(NULL, FALSE, to_name);

if (d_mutex_to_h == NULL)
{
   d_mutex_to_h = OpenMutex(NULL, FALSE, to_name);
}

我需要一些有关 Cuda GLOBAL 内存的帮助。在我的项目中，我必须声明全局数组以避免在每次内核调用时发送这个数组。

编辑：

我的应用程序可以调用内核超过 1,000 次，每次调用时我都会向他发送一个大小超过 [1000 X 1000] 的数组，所以我认为这需要更多时间，这就是我的应用程序运行缓慢的原因。所以我需要为 GPU 声明全局数组，所以我的问题是

1如何声明全局数组

2如何在内核调用之前从 CPU 初始化全局数组

提前致谢

Linux内核如何实现不同进程间的共享内存机制？

更详细地说，每个进程都有自己的地址空间。例如，与进程 B 中的地址 0x1000 相比，进程 A 中的地址 0x1000 是不同的位置。

那么内核如何确保一块内存在不同进程之间共享，具有不同的地址空间？

提前致谢。

从 PHP，它说

int shmop_open ( int $key , string $flags , int $mode , int $size )

其中 $key 是

共享内存块的系统 ID。可以作为十进制或十六进制传递。

有些人用任意数字（1）填充 $key，而其他人使用文件来获取 $key 值（2）。$key 是随机值吗？

(1)

   $shm_id = shmop_open(987654, "c", 0644, 100);

(2)

   $shm_key = ftok(__FILE__, 't');
   $shm_id = shmop_open($shm_key, "c", 0644, 100);

顺便说一句，在 Windows 中，我使用了一个小数字，虽然它有效，但我最多只能使用 1024 个字节。在为密钥使用大数字时，我能够处理更多内存。为什么？。

我正在将现有的 linux 应用程序移植到 android。该应用程序正在使用共享内存 API 等shm_open()。

检查android source 中的仿生，我发现这些 API 不受支持。因此我在构建过程中遇到链接错误。

external/l2/avbtp.c:138: error: undefined reference to 'shm_open'
external/l2/avbtp.c:151: error: undefined reference to 'shm_unlink'
external/l2/avbtp.c:186: error: undefined reference to 'shm_unlink'

如何正确解决这个问题？

shmget 用于 Linux 中的 IPC

有人可以解释一下上面代码中的 shmget() unix 系统调用中的 IPC_CREAT |0666 到底做了什么，我知道 0666 在这里是八进制值，但更改它根本没有任何影响。

关于 OpenMP 中的共享变量，我有一个非常基本的问题（可能很愚蠢）。考虑以下代码：

void main()
{
int numthreads;
#pragma omp parallel default(none) shared(numthreads)
 {
  numthreads = omp_get_num_threads();
  printf("%d\n",numthreads);
 }
}

现在numthreads所有线程的值都相同。是否有可能因为不同的线程将相同的值写入相同的变量，该值可能会出现乱码/损坏？或者这个对原始数据类型的操作是否保证是原子的？

我阅读了 C++ 标准 (n4713) 的 § 32.6.1 3：

无锁的操作也应该是无地址的。也就是说，通过两个不同地址对同一内存位置的原子操作将进行原子通信。实现不应依赖于任何每个进程的状态。此限制允许通过多次映射到进程的内存和在两个进程之间共享的内存进行通信。

所以听起来可以在同一内存位置执行无锁原子操作。我想知道怎么做。

假设我在 Linux 上有一个命名的共享内存段（通过 shm_open() 和 mmap()）。例如，如何对共享内存段的前 4 个字节执行无锁操作？

起初，我以为我可以只reinterpret_cast指向std::atomic<int32_t>*. 但后来我读到了这个。它首先指出 std::atomic 可能没有相同大小的 T 或对齐：

当我们设计 C++11 原子时，我误以为可以使用诸如

int x; reinterpret_cast<atomic<int>&>(x).fetch_add(1);

如果 atomic 和 int 的表示不同，或者它们的对齐方式不同，这显然会失败。但我知道这在我关心的平台上不是问题。而且，在实践中，我可以通过在编译时检查大小和对齐方式匹配来轻松测试问题。

Tho，在这种情况下对我来说很好，因为我在同一台机器上使用共享内存，并且在两个不同的进程中投射指针将“获取”相同的位置。但是，文章指出编译器可能不会将强制转换的指针视为指向原子类型的指针：

然而，这不能保证是可靠的，即使在人们可能期望它工作的平台上，因为它可能会混淆编译器中基于类型的别名分析。编译器可能会假设 int 也不会作为atomic<int>. （见 3.10，[Basic.lval]，最后一段。）

欢迎任何输入！

在我的应用程序中，我有两个类，一个继承自 kotlin 类的 swift 类：

迅捷类：

public class MySensor: RawSensor

    [...]

    public override func notifyChanged(values: KotlinFloatArray) {
      super.notifyChanged(values: values)
    }
}

科特林类：

package com.mycompany.myapp.mypackage.sensors.rawsensors

import com.mycompany.myapp.mypackage.util.Observable

abstract class RawSensor : Observable() {

  protected abstract val sensorDataType: RawSensorData.SensorDataType

  abstract val currentTime: Long

  protected open fun notifyChanged(values: FloatArray) {
      notifyObservers(RawSensorData(values, sensorDataType, currentTime))
  }

  abstract fun start()

  abstract fun stop()
}

当super.notifyChanged(values: values)被调用时，应用程序崩溃，并出现以下错误：

Uncaught Kotlin exception: kotlin.native.IncorrectDereferenceException: illegal attempt to access non-shared <object>@83cb47c8 from other thread
Uncaught Kotlin exception: kotlin.native.IncorrectDereferenceException: illegal …

我正在使用 Python 3.8 的新shared_memory模块并且无法在不终止使用它的进程的情况下释放共享内存。

在创建和使用shm共享内存块后，我shm.close()在所有进程中关闭它，最后shm.unlink在主进程中释放它。但是，资源监视器显示内存在程序终止之前不会被释放。这对我来说是一个严重的问题，因为我的程序需要运行很长时间。可以使用以下程序在 Windows/Python 3.8 上重现该问题：

from multiprocessing import shared_memory, Pool
from itertools import repeat
from time import sleep

def fun(dummy, name):
    
    # access shared memory
    shm = shared_memory.SharedMemory(name=name)
    
    # do work
    sleep(1)
    
    # release shared memory
    shm.close()
    
    return dummy

def meta_fun(pool):
    
    # create shared array
    arr = shared_memory.SharedMemory(create=True, size=500000000)
    
    # compute result
    result = sum(pool.starmap(fun, zip(range(10), repeat(arr.name))))
    
    # release and free memory
    arr.close()
    arr.unlink()
    
    return result

if …