Chapter17— Memory-Mapping Files 进程间共享数据进行通信

本文详细介绍了如何使用Windows API中的CreateFileMapping和MapViewOfFile函数创建和映射Memory-MappedFile,进而实现不同进程间的共享数据和通信。通过实例演示了从创建Memory-MappedFile到映射、读写、解除映射直至关闭的完整过程,并提供了关键代码示例。

第十七章的实例有个利用 Memory-Mapped File 来实现进程间共享数据和通信。

Step1:调用CreateFileMapping 函数创建一个 Memory-Mapped File Object。

该函数的原型如下:

HANDLE WINAPI CreateFileMapping(
  __in          HANDLE hFile,
  __in          LPSECURITY_ATTRIBUTES lpAttributes,
  __in          DWORD flProtect,
  __in          DWORD dwMaximumSizeHigh,
  __in          DWORD dwMaximumSizeLow,
  __in          LPCTSTR lpName
);
  • 第一个参数 hFile 设为INVALID_HANDLE_VALUE 表示你仅是将该 Memory-Mapped File Object 存放在 系统的分页文件中,而不是某个指定的磁盘文件当中。
  • 第二个参数 lpAttributes 是安全属性,一般默认是 NULL
  • 第三个参数 flProtect 是指定文件视图的保护属性的。具体的就参考MSDN,下面实例中就使用PAGE_READWRITE 值,表示有读写权限
  • 第四个参数 dwMaximumSizeHigh ,指定最大文件视图大小中64-bit中的高32位
  • 第五个参数dwMaximumSizeHigh,指定最大文件视图大小中64-bit中的低32位
  • 第六个参数 lpName,指定给文件视图的名字。

Step2:调用MapViewOfFile 函数将文件视图映射入 进程地址空间。

该函数的原型如下:

LPVOID WINAPI MapViewOfFile(
  __in          HANDLE hFileMappingObject,
  __in          DWORD dwDesiredAccess,
  __in          DWORD dwFileOffsetHigh,
  __in          DWORD dwFileOffsetLow,
  __in          SIZE_T dwNumberOfBytesToMap
);

  • 第一个参数 hFileMappingObject 就填入 上面 CreateFileMapping 函数的返回值
  • 第二个参数 dwDesiredAccess ,指定进程的访问权
  • 限,下面实例中使用FILE_MAP_READ | FILE_MAP_WRITE 表示有读写权限,注意此处的权限不能高于试图文件本身的权限,即第一步中指定的 flProtect 指定的权限。
  • 第三个参数 dwFileOffsetHigh,表示视图文件的偏移量64位中的高 32 位
  • 第四个参数 dwFileOffsetLow,表示视图文件的偏移量64位中的低 32 位
  • 第五个参数 dwNumberOfBytesToMap,表示总有多少个字节被映射入该进程的地址空间

Step3:读写 mapping file 内容

第三步中MapViewOfFile 函数返回一个指针,通过该指针就可以实现对 mapping file 的读写,这样进程间就可以进行通信了。


Step4:之后调用UnmapViewOfFile 将Memory-Mapping File 从进程的地址空间中移除


Step5:最后关闭 Memory-Mapping File 句柄


运行过程截图如下



代码示例

#include <windows.h>
#include <TCHAR.H>
#include <stdio.h>

void main()
{
    int choice;
    HANDLE hFile_Map = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4 * 1024, TEXT("MMFSharedData"));

    if (hFile_Map == NULL)
    {
        printf("Failed to create file mapping!\n");
        getchar();

        return;
    }
    else if (GetLastError() == ERROR_ALREADY_EXISTS)
    {
        printf("Mapping already exists - not created.\n");
        getchar();
    }

    // File mapping created successfully.

    // Map a view of the file into the address space.
    PVOID pView = MapViewOfFile(hFile_Map, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
    if (NULL == pView)
    {
        printf("Failed to map view of file.\n");
        getchar();

        return;
    }

    while (true)
    {
        getchar();
        system("cls");
        printf("\n\t1.写入 mapping file 内容.");
        printf("\n\t2.读取 mapping file 内容.");
        printf("\n\t3.退出程序");
        printf("\n\n请输入你的选择序号:");
        scanf("%d", &choice);

        if (choice == 3)
      break;

    switch (choice)
    {
    case 1:
      printf("输入要写入的内容:");
      scanf("%s", pView);
      break;
    case 2:
      printf("显示已写入的内容:");
      printf("%s\n", pView);
      break;
        default:
            printf("你的选择序号有误。\n");
            break;
        }
        getchar();
    }
    
    UnmapViewOfFile(pView);
    CloseHandle(hFile_Map);    
}

《windows核心编程》(笔记)系列文章是本人看《windows核心编程》时的一些学习笔记,有疏忽之处,欢迎各位网友指正。QQ邮箱:job.zhanghui@qq.com

Chapter 4: Processor Architecture. This chapter covers basic combinational and sequential logic elements, and then shows how these elements can be combined in a datapath that executes a simplified subset of the x86-64 instruction set called “Y86-64.” We begin with the design of a single-cycle datapath. This design is conceptually very simple, but it would not be very fast. We then introduce pipelining, where the different steps required to process an instruction are implemented as separate stages. At any given time, each stage can work on a different instruction. Our five-stage processor pipeline is much more realistic. The control logic for the processor designs is described using a simple hardware description language called HCL. Hardware designs written in HCL can be compiled and linked into simulators provided with the textbook, and they can be used to generate Verilog descriptions suitable for synthesis into working hardware. Chapter 5: Optimizing Program Performance. This chapter introduces a number of techniques for improving code performance, with the idea being that programmers learn to write their C code in such a way that a compiler can then generate efficient machine code. We start with transformations that reduce the work to be done by a program and hence should be standard practice when writing any program for any machine. We then progress to transformations that enhance the degree of instruction-level parallelism in the generated machine code, thereby improving their performance on modern “superscalar” processors. To motivate these transformations, we introduce a simple operational model of how modern out-of-order processors work, and show how to measure the potential performance of a program in terms of the critical paths through a graphical representation of a program. You will be surprised how much you can speed up a program by simple transformations of the C code. Bryant & O’Hallaron fourth pages 2015/1/28 12:22 p. xxiii (front) Windfall Software, PCA ZzTEX 16.2 xxiv Preface Chapter 6: The Memory Hierarchy. The memory system is one of the most visible parts of a computer system to application programmers. To this point, you have relied on a conceptual model of the memory system as a linear array with uniform access times. In practice, a memory system is a hierarchy of storage devices with different capacities, costs, and access times. We cover the different types of RAM and ROM memories and the geometry and organization of magnetic-disk and solid state drives. We describe how these storage devices are arranged in a hierarchy. We show how this hierarchy is made possible by locality of reference. We make these ideas concrete by introducing a unique view of a memory system as a “memory mountain” with ridges of temporal locality and slopes of spatial locality. Finally, we show you how to improve the performance of application programs by improving their temporal and spatial locality. Chapter 7: Linking. This chapter covers both static and dynamic linking, including the ideas of relocatable and executable object files, symbol resolution, relocation, static libraries, shared object libraries, position-independent code, and library interpositioning. Linking is not covered in most systems texts, but we cover it for two reasons. First, some of the most confusing errors that programmers can encounter are related to glitches during linking, especially for large software packages. Second, the object files produced by linkers are tied to concepts such as loading, virtual memory, and memory mapping. Chapter 8: Exceptional Control Flow. In this part of the presentation, we step beyond the single-program model by introducing the general concept of exceptional control flow (i.e., changes in control flow that are outside the normal branches and procedure calls). We cover examples of exceptional control flow that exist at all levels of the system, from low-level hardware exceptions and interrupts, to context switches between concurrent processes, to abrupt changes in control flow caused by the receipt of Linux signals, to the nonlocal jumps in C that break the stack discipline. This is the part of the book where we introduce the fundamental idea of a process, an abstraction of an executing program. You will learn how processes work and how they can be created and manipulated from application programs. We show how application programmers can make use of multiple processes via Linux system calls. When you finish this chapter, you will be able to write a simple Linux shell with job control. It is also your first introduction to the nondeterministic behavior that arises with concurrent program execution. Chapter 9: Virtual Memory. Our presentation of the virtual memory system seeks to give some understanding of how it works and its characteristics. We want you to know how it is that the different simultaneous processes can each use an identical range of addresses, sharing some pages but having individual copies of others. We also cover issues involved in managing and manipulating virtual memory. In particular, we cover the operation of storage allocators such as the standard-library malloc and free operations. CovBryant & O’Hallaron fourth pages 2015/1/28 12:22 p. xxiv (front) Windfall Software, PCA ZzTEX 16.2 Preface xxv ering this material serves several purposes. It reinforces the concept that the virtual memory space is just an array of bytes that the program can subdivide into different storage units. It helps you understand the effects of programs containing memory referencing errors such as storage leaks and invalid pointer references. Finally, many application programmers write their own storage allocators optimized toward the needs and characteristics of the application. This chapter, more than any other, demonstrates the benefit of covering both the hardware and the software aspects of computer systems in a unified way. Traditional computer architecture and operating systems texts present only part of the virtual memory story. Chapter 10: System-Level I/O. We cover the basic concepts of Unix I/O such as files and descriptors. We describe how files are shared, how I/O redirection works, and how to access file metadata. We also develop a robust buffered I/O package that deals correctly with a curious behavior known as short counts, where the library function reads only part of the input data. We cover the C standard I/O library and its relationship to Linux I/O, focusing on limitations of standard I/O that make it unsuitable for network programming. In general, the topics covered in this chapter are building blocks for the next two chapters on network and concurrent programming. Chapter 11: Network Programming. Networks are interesting I/O devices to program, tying together many of the ideas that we study earlier in the text, such as processes, signals, byte ordering, memory mapping, and dynamic storage allocation. Network programs also provide a compelling context for concurrency, which is the topic of the next chapter. This chapter is a thin slice through network programming that gets you to the point where you can write a simple Web server. We cover the client-server model that underlies all network applications. We present a programmer’s view of the Internet and show how to write Internet clients and servers using the sockets interface. Finally, we introduce HTTP and develop a simple iterative Web server. Chapter 12: Concurrent Programming. This chapter introduces concurrent programming using Internet server design as the running motivational example. We compare and contrast the three basic mechanisms for writing concurrent programs—processes, I/O multiplexing, and threads—and show how to use them to build concurrent Internet servers. We cover basic principles of synchronization using P and V semaphore operations, thread safety and reentrancy, race conditions, and deadlocks. Writing concurrent code is essential for most server applications. We also describe the use of thread-level programming to express parallelism in an application program, enabling faster execution on multi-core processors. Getting all of the cores working on a single computational problem requires a careful coordination of the concurrent threads, both for correctness and to achieve high performance翻译以上英文为中文
08-05
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值