标签: shared-memory

我正在开发一个使用共享内存和互锁功能的系统.

我们假设我有volatile unsigned int n, a, b.我想原子地执行以下伪代码:

if (a <= n && n < b)
{
    n++;
}
else
{
    //Do nothing
}

我该怎么办？你可以一起使用多个互锁功能吗？

有没有人有CreateSharedMemory函数(Windows)用法的例子？在共享内存中的客户机/服务器软件方案中的服务器输入参数的功能仅仅是MaxSize和InitialSize,因此只要客户怎样知道什么存储器地址共享？CreateFileMapping解决了这个问题,因为您可以命名每个文件映射对象.我知道Boost具有类似的功能,但我希望使用原始Windows API功能来解决这个问题.

我有一段代码设置为采用一个恒定的整数参数(问题的维度),但它可以运行许多不同的维度.

我不想每次运行时都要更改硬编码维度,理想情况下我会定义几个基本上只是的虚拟头函数:

#ifndef dim_define_h 
#define dim_define_h 

    const int dimension = [DIMENSION SPECIFIC TO THIS HEADER FILE];

#endif

然后在编译时我可以使用该实例所需的头文件,如:

g++ dimension_6.h code.cpp

这样的事情可能吗？在头文件中定义一个常量并在另一个没有显式导入该头文件的文件中使用它？

编辑:

我的下一次尝试是仅使用main函数,将其与维度定义一起粘贴在不同的文件中,然后复制它.然后编译看起来像:

g++ dim_specific_main.cpp lots.cpp more.cpp helpers.cpp

而且我认为它正在通过main的编译来实现,它依赖于所有帮助文件中定义的辅助函数.不幸的是,当它试图编译辅助函数时,它需要在main.h中定义的常量,它似乎忘记了它.

编辑2:我现在意识到我正在尝试在需要在编译时知道的地方使用这个变量,并且我认为链接在编译之后发生,所以我不相信这种特殊的方法是可能的.

我想了解共享内存是否从内核空间获取内存分配，那么为什么不通过上下文切换呢？如果不是来自内核空间，则从那里分配内存。

我有一些代码，我一生都无法弄清楚这些是如何共享内存的！！！！所有测试都是错误的（如图所示），然而，内存位置在功能上和视觉上似乎都相同。我花了几个小时试图排除故障，但无法弄清楚。 请帮忙！！！为什么这些阵列共享内存！？？

listOfValues和listOfxValues在不应该共享内存时共享内存。

警告：丑陋，丑陋的代码，我很抱歉，这是艰难的一天。

listOfLists = []
splitold=0

#split arrays into each bin
for split in splitInd:
    splitnew=split
    listOfLists.append(xind[splitold:splitnew])
    splitold=split

listOfValues = np.array(listOfLists.copy())
#convert to float type
for i,lst in enumerate(listOfValues):
    listOfValues[i] = lst.astype(float)

listOfxValues = np.copy(listOfValues)

#PRINT TROUBLESHOOTING
print(listOfxValues.data)
print(listOfValues.data)
print(listOfValues is listOfxValues)
print(listOfValues == listOfxValues)
print(listOfValues.data is listOfxValues.data)
print(listOfValues.data == listOfxValues.data)
print(np.shares_memory(listOfxValues,listOfValues))
print(listOfxValues.__array_interface__['data'][0] == listOfValues.__array_interface__['data'][0]) 
print(listOfxValues.__array_interface__['data'][0] == listOfValues.__array_interface__['data'][0])

#exchange indexed values for real values
for each in range(len(listOfValues)):
    for …

在我尝试的任何 React Native+Flow 项目中，我都会遇到共享内存不足的情况。这是日志消息：

[2021-01-16 21:01:45.042] argv=/Users/hugo/Desktop/Admin MacBook/BeneTalk3/node_modules/flow-bin/flow-osx-v0.122.0/flow start --flowconfig-name .flowconfig --temp-dir /tmp/flow /Users/hugo/Desktop/Admin MacBook/BeneTalk3
[2021-01-16 21:01:45.042] lazy_mode=off
[2021-01-16 21:01:45.042] arch=classic
[2021-01-16 21:01:45.042] abstract_locations=off
[2021-01-16 21:01:45.042] max_workers=8
[2021-01-16 21:01:45.042] Failed to use anonymous memfd init
Out of shared memory:
Raised by primitive operation at file "src/heap/sharedMem.ml", line 43, characters 6-40

在 intel Mac 上运行良好，但似乎无法在 M1 上运行。

shmget.c:

#include<sys/types.h>
#include<string.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<stdio.h>
main()
{
    key_t key;
    int shmid;
    char* addr1;
    key = ftok("/home/tamil/myc/pws.c",'T');
    shmid = shmget(key,128*1024,IPC_CREAT|SHM_R|SHM_W);

    addr1 = shmat(shmid,0,0);

    printf("\nIPC SHARED MEMORY");
    printf("\n SENDER ADDRESS");
    printf("\nTHE ADDRESS IS %p",addr1);
    printf("\nENTER THE MESSAGE:");
    scanf("%s",addr1);
    printf("\nMESSAGE STORED IN %p IS %s",addr1,addr1);  
}

shmget2.c:

#include<sys/types.h>
#include<string.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<stdio.h>

main()
{
    int shmid;
    char* addr1;
    key_t key;


    key = ftok("/home/tamil/myc/pws.c",'T');
    shmid = shmget(key,128*1024,SHM_R|SHM_W);

    addr1 = shmat(shmid,0,0);


    printf("\nIPC SHARED MEMORY");
    printf("\n SENDER ADDRESS");
    printf("\nTHE ADDRESSS IS %p",addr1);
    printf("\nMESSAGE STORED IN …

我需要写共享内存,因此我有

#define FLAGS IPC_CREAT | 0644
int main() {
key = ftok("ex31.c", 'k');
shmid = shmget(key, 3, FLAGS);
shmaddr = shmat(shmid,0,0);    // THOSE LINES WORK AS EXPECTED

char* userInput = malloc(5);
read(0, userInput, 3);  // I want to read "b34" for example, WORKS GOOD
strcpy(shmaddr,userInput);   // THROWS EXCEPTION!
}

它会抛出异常strcat,如果我删除它,则会在下一行抛出异常strcpy.我需要写入内存" b34\0"(4个字符),然后读取它.

在 Go 中，使用sync.Mutexor来防止共享对象的并发访问。chan但是，在某些情况下，我只对对象的变量或字段的“最新”值感兴趣。或者我喜欢写一个值，并不关心另一个 go 例程稍后会覆盖它还是之前刚刚覆盖它。

更新： TLDR；只是不要这样做。这是不安全的。阅读答案、评论和链接文档！

2021 年更新： Go 内存模型将被更彻底地指定， Russ Cox 撰写的三篇精彩文章将教您更多关于不同步内存访问的令人惊讶的影响。这些文章总结了以下许多讨论和学习内容。

以下是示例程序的两个变体，两者似乎都使用当前的 Go 运行时产生“正确”的good输出：bad

package main

import (
    "flag"
    "fmt"
    "math/rand"
    "time"
)

var bogus = flag.Bool("bogus", false, "use bogus code")

func pause() {
    time.Sleep(time.Duration(rand.Uint32()%100) * time.Millisecond)
}

func bad() {
    stop := time.After(100 * time.Millisecond)
    var name string

    // start some producers doing concurrent writes (DANGER!)
    for i := 0; i < 10; i++ { …

我正在使用Ubuntu 12,当我在终端上编译代码时,我使用: $ g++ -o ./myProgram ./main.cpp,然后 $ ./myProgram 我没有得到任何错误或警告,但它不会打印主函数之外的任何内容.

由于某种原因,似乎主函数中的pthread_creat命令不起作用.

这是我的程序代码:

#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <unistd.h>
#include <time.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/stat.h>

using namespace std;

pthread_mutex_t jobMutex;
key_t key = 5678;
#define SHMSZ 27

int shmid;

class Job {
public:
int speed, pleasant, easy;

//initialization, constructor, destructor

Job() {
}

Job(int new_s, int new_p, int new_e) {
    speed = new_s;
    pleasant = new_p;
    easy = new_e;
}

~Job() { …

I'm learning concurrency-related issues in Golang. I wrote some code:

package main

import (
    "fmt"
    "time"
)

func incr(num *int) {
    *num = *num + 1

}

func main() {
    var a = 0

    for i := 0; i < 50; i++ {
        go incr(&a)
    }

    incr(&a)

    time.Sleep(1 * time.Second)
    fmt.Println(a)
}

The result of this code is: 51

In this code I've declared a variable which I'm increasing in 50 running goroutines. What I've read and unsterstood this code …

我在共享内存段中使用一个简单的 pthreads 进程共享互斥锁来协调多个服务器实例。

代码是直接的：
在启动时服务器附连到共享存储器段（如果存在），或创建它，如果它不：
shm_open()，mmap(MAP_SHARED)等

这在测试时效果很好，但是一旦部署一段时间后，我就会遇到服务器实例根本不协调的情况。我可以通过在服务器启动后删除共享内存段来复制这一点：未来的服务器实例将创建/使用一个新段，但现有的一个被困在没有人使用的旧段中，因此实际上它与其余部分隔离......

所以我的猜测是 /dev/shm 中的共享内存段以某种方式被删除了，而不是我。这是唯一有意义的事情......这里发生了什么？

使用 linux 4.9 运行 debian。

我知道这可能与编程中的许多一般规则背道而驰,但你会怎么做呢？我问这个有两个原因:

1. 我想尝试让应用程序将数据写入RAM,另一个用于从RAM读取相同的数据.
2. 我想知道因为在不久的将来我将不得不优化一个java应用程序.