MEMORY_BASIC_INFORMATION结构

最新推荐文章于 2021-11-30 15:56:06 发布
最新推荐文章于 2021-11-30 15:56:06 发布
阅读量5.2k 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/missile1226/article/details/8218366
版权

MEMORY_BASIC_INFORMATION这个结构中的两个成员的区别：

typedef struct _MEMORY_BASIC_INFORMATION {  
PVOID BaseAddress;  
PVOID AllocationBase;  
DWORD AllocationProtect;  
SIZE_T RegionSize;  
DWORD State;  
DWORD Protect;  
DWORD Type;
} MEMORY_BASIC_INFORMATION,  *PMEMORY_BASIC_INFORMATION; 



以下引用csdn论坛的观点，我认为这解释地比较清楚了：
PVOID BaseAddress;  //该页的基地址，是VirtualQuery(Ex)第一个参数下舍入下一个页面的边界的值
页的边界启始地址. 在地址形式上类似: 0xXXXXX000(X86,页大小为4KB） 

PVOID AllocationBase;

在进程中为了使用内存,必须保留(Reserved)内存和占有内存(Committed) -使用VirtualAlloc()函数. VirtualAlloc分配的内存称为区域(Region)- 一片连续的页. 为了分配效率(?) Windows会以64-KB为边界计算区域的启始地址,所以区域的启始地址在形式上类似: 0xXXXX0000，这里的64KB页就是所谓的分配粒度，因此 AllocationBase正是一个区域(Region)的启始地址


另外，BaseAddress一定在AllocationBase地址范围之内
(The page pointed to by the BaseAddress member is contained within this allocation range)
以下是我在应用VirtualQuery函数时MEMORY_BASIC_INFORMATION结构里面的
PVOID BaseAddress;
PVOID AllocationBase;两个成员的返回值

=================================
BaseAddress   AllocationBase
0x00401000    0x00400000
0x00401700    0x00400000
0x00401800    0x00400000
0x00401a00    0x00400000

=================================

BaseAddress - the address of the queried memory page ( VirtualQuery(LPCVOID lpAddress,... ).

AllocationBase - the beginning of the allocated memory block. It is used for deallocation. BaseAddress >= AllocationBase.

If you are querying stack then AllocationBase will be the lowest address of the stack (the stack top)


missile1226
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
virtual memory
03-08
good memory express~you can find many useful express for the basic information about the virtual memory
deep q_learning
06-19
# Deep Reinforcement Learning for Keras [![Build Status](https://api.travis-ci.org/matthiasplappert/keras-rl.svg?branch=master)](https://travis-ci.org/matthiasplappert/keras-rl) [![Documentation](https://readthedocs.org/projects/keras-rl/badge/)](http://keras-rl.readthedocs.io/) [![License](https://img.shields.io/github/license/mashape/apistatus.svg?maxAge=2592000)](https://github.com/matthiasplappert/keras-rl/blob/master/LICENSE) [![Join the chat at https://gitter.im/keras-rl/Lobby](https://badges.gitter.im/keras-rl/Lobby.svg)](https://gitter.im/keras-rl/Lobby) ## What is it? `keras-rl` implements some state-of-the art deep reinforcement learning algorithms in Python and seamlessly integrates with the deep learning library [Keras](http://keras.io). Just like Keras, it works with either [Theano](http://deeplearning.net/software/theano/) or [TensorFlow](https://www.tensorflow.org/), which means that you can train your algorithm efficiently either on CPU or GPU. Furthermore, `keras-rl` works with [OpenAI Gym](https://gym.openai.com/) out of the box. This means that evaluating and playing around with different algorithms is easy. Of course you can extend `keras-rl` according to your own needs. You can use built-in Keras callbacks and metrics or define your own. Even more so, it is easy to implement your own environments and even algorithms by simply extending some simple abstract classes. In a nutshell: `keras-rl` makes it really easy to run state-of-the-art deep reinforcement learning algorithms, uses Keras and thus Theano or TensorFlow and was built with OpenAI Gym in mind. ## What is included? As of today, the following algorithms have been implemented: - Deep Q Learning (DQN) [[1]](http://arxiv.org/abs/1312.5602), [[2]](http://home.uchicago.edu/~arij/journalclub/papers/2015_Mnih_et_al.pdf) - Double DQN [[3]](http://arxiv.org/abs/1509.06461) - Deep Deterministic Policy Gradient (DDPG) [[4]](http://arxiv.org/abs/1509.02971) - Continuous DQN (CDQN or NAF) [[6]](http://arxiv.org/abs/1603.00748) - Cross-Entropy Method (CEM) [[7]](http://learning.mpi-sws.org/mlss2016/slides/2016-MLSS-RL.pdf), [[8]](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.81.6579&rep=rep1&type=pdf) - Dueling network DQN (Dueling DQN) [[9]](https://arxiv.org/abs/1511.06581) - Deep SARSA [[10]](http://people.inf.elte.hu/lorincz/Files/RL_2006/SuttonBook.pdf) You can find more information on each agent in the [wiki](https://github.com/matthiasplappert/keras-rl/wiki/Agent-Overview). I'm currently working on the following algorithms, which can be found on the `experimental` branch: - Asynchronous Advantage Actor-Critic (A3C) [[5]](http://arxiv.org/abs/1602.01783) Notice that these are **only experimental** and might currently not even run. ## How do I install it and how do I get started? Installing `keras-rl` is easy. Just run the following commands and you should be good to go: ```bash pip install keras-rl ``` This will install `keras-rl` and all necessary dependencies. If you want to run the examples, you'll also have to install `gym` by OpenAI. Please refer to [their installation instructions](https://github.com/openai/gym#installation). It's quite easy and works nicely on Ubuntu and Mac OS X. You'll also need the `h5py` package to load and save model weights, which can be installed using the following command: ```bash pip install h5py ``` Once you have installed everything, you can try out a simple example: ```bash python examples/dqn_cartpole.py ``` This is a very simple example and it should converge relatively quickly, so it's a great way to get started! It also visualizes the game during training, so you can watch it learn. How cool is that? Unfortunately, the documentation of `keras-rl` is currently almost non-existent. However, you can find a couple of more examples that illustrate the usage of both DQN (for tasks with discrete actions) as well as for DDPG (for tasks with continuous actions). While these examples are not replacement for a proper documentation, they should be enough to get started quickly and to see the magic of reinforcement learning yourself. I also encourage you to play around with other environments (OpenAI Gym has plenty) and maybe even try to find better hyperparameters for the existing ones. If you have questions or problems, please file an issue or, even better, fix the problem yourself and submit a pull request! ## Do I have to train the models myself? Training times can be very long depending on the complexity of the environment. [This repo](https://github.com/matthiasplappert/keras-rl-weights) provides some weights that were obtained by running (at least some) of the examples that are included in `keras-rl`. You can load the weights using the `load_weights` method on the respective agents. ## Requirements - Python 2.7 - [Keras](http://keras.io) >= 1.0.7 That's it. However, if you want to run the examples, you'll also need the following dependencies: - [OpenAI Gym](https://github.com/openai/gym) - [h5py](https://pypi.python.org/pypi/h5py) `keras-rl` also works with [TensorFlow](https://www.tensorflow.org/). To find out how to use TensorFlow instead of [Theano](http://deeplearning.net/software/theano/), please refer to the [Keras documentation](http://keras.io/#switching-from-theano-to-tensorflow). ## Documentation We are currently in the process of getting a proper documentation going. [The latest version of the documentation is available online](http://keras-rl.readthedocs.org). All contributions to the documentation are greatly appreciated! ## Support You can ask questions and join the development discussion: - On the [Keras-RL Google group](https://groups.google.com/forum/#!forum/keras-rl-users). - On the [Keras-RL Gitter channel](https://gitter.im/keras-rl/Lobby). You can also post **bug reports and feature requests** (only!) in [Github issues](https://github.com/matthiasplappert/keras-rl/issues). ## Running the Tests To run the tests locally, you'll first have to install the following dependencies: ```bash pip install pytest pytest-xdist pep8 pytest-pep8 pytest-cov python-coveralls ``` You can then run all tests using this command: ```bash py.test tests/. ``` If you want to check if the files conform to the PEP8 style guidelines, run the following command: ```bash py.test --pep8 ``` ## Citing If you use `keras-rl` in your research, you can cite it as follows: ```bibtex @misc{plappert2016kerasrl, author = {Matthias Plappert}, title = {keras-rl}, year = {2016}, publisher = {GitHub}, journal = {GitHub repository}, howpublished = {\url{https://github.com/matthiasplappert/keras-rl}}, } ``` ## Acknowledgments The foundation for this library was developed during my work at the [High Performance Humanoid Technologies (H²T)](https://h2t.anthropomatik.kit.edu/) lab at the [Karlsruhe Institute of Technology (KIT)](https://kit.edu). It has since been adapted to become a general-purpose library. ## References 1. *Playing Atari with Deep Reinforcement Learning*, Mnih et al., 2013 2. *Human-level control through deep reinforcement learning*, Mnih et al., 2015 3. *Deep Reinforcement Learning with Double Q-learning*, van Hasselt et al., 2015 4. *Continuous control with deep reinforcement learning*, Lillicrap et al., 2015 5. *Asynchronous Methods for Deep Reinforcement Learning*, Mnih et al., 2016 6. *Continuous Deep Q-Learning with Model-based Acceleration*, Gu et al., 2016 7. *Learning Tetris Using the Noisy Cross-Entropy Method*, Szita et al., 2006 8. *Deep Reinforcement Learning (MLSS lecture notes)*, Schulman, 2016 9. *Dueling Network Architectures for Deep Reinforcement Learning*, Wang et al., 2016 10. *Reinforcement learning: An introduction*, Sutton and Barto, 2011 ## Todos - Documentation: Work on the documentation has begun but not everything is documented in code yet. Additionally, it would be super nice to have guides for each agents that describe the basic ideas behind it. - TRPO, priority-based memory, A3C, async DQN, ...
System Hardware Information Finder
07-26
This article is an update to my previous articles on the same topic. I started this utility to get some basic information about the hardware. After that I have received some emails from some of our fellow programmers, who are frequent visitors of this site, asking to extend this utility to spit out some more information. In this update I have added the information about CPU vendor (Intel, Cyrix, AMD, etc.) ,CPU speed, and Physical memory status of sustem . CPU Information: To get CPU information I could not find any direct and simple API call. Then I thought of our friendly Registry, which contains all the system information. And there it was all the information I wanted. If you look under HKEY_LOCAL_MACHINE/Hardware/Description/System/CentralProcessor/0 key in registry, you will find the answers to your questions. ~MHz subkey gives the CPU speed and VendorIdentifier gives the vendor information. We will make use of RegQueryValueEx API call to get the information. LONG RegQueryValueEx( HKEY hKey, // handle to key to query LPTSTR lpValueName, // address of name of value to query LPDWORD lpReserved, // reserved LPDWORD lpType, // address of buffer for value type LPBYTE lpData, // address of data buffer LPDWORD lpcbData // address of data buffer size ); Before making this call, it is necessary to create the handle to registry key which needs to be queried. For this make use of RegCreateKeyEx API call. This is how the code looks like in the included code for this utility. // Get the processor speed info. result = ::RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Hardware\\Description\\System\\CentralProcessor\\0", 0, KEY_QUERY_VALUE, &hKey); // Check if the function has succeeded. if (result == ERROR_SUCCESS) { result = ::RegQueryValueEx (hKey, _T("~MHz"), NULL, NULL, (LPBYTE)&data, &dataSize); m_stCPUSpeed.Format ("%d", data); m_stCPUSpeed += _T (" MHz"); dataSize = sizeof (vendorData); result = ::RegQueryValueEx (hKey, _T("VendorIdentifier"), NULL, NULL, (LPBYTE)vendorData, &dataSize); m_stVendorInfo.Format ("%s", vendorData); } // Make sure to close the reg key RegCloseKey (hKey); Since I don't have access to any other CPU than Intel. So I couldn't test this code on CPU's from Cyrix, AMD, etc. Post a comment Email Article Print Article Share Articles Digg del.icio.us Newsvine Facebook Google LinkedIn MySpace Reddit Slashdot StumbleUpon Technorati Twitter Windows Live YahooBuzz FriendFeed Physical Memory Status: To get the information about the memory status of the system we can take routes. First one, which is not easy for a person who does not know assembly language, involves getting the required information from CMOS data. Second one which simply involves making GlobalMemoryStatus API call. And I chose the second one (Ofcourse I am not assembly language pro). VOID GlobalMemoryStatus ( LPMEMORYSTATUS lpBuffer // pointer to the memory status structure ); The information is returned in MEMORYSTATUS data structure. typedef struct _MEMORYSTATUS { // mst DWORD dwLength; // sizeof(MEMORYSTATUS) DWORD dwMemoryLoad; // percent of memory in use DWORD dwTotalPhys; // bytes of physical memory DWORD dwAvailPhys; // free physical memory bytes DWORD dwTotalPageFile; // bytes of paging file DWORD dwAvailPageFile; // free bytes of paging file DWORD dwTotalVirtual; // user bytes of address space DWORD dwAvailVirtual; // free user bytes } MEMORYSTATUS, *LPMEMORYSTATUS; The information returned by the GlobalMemoryStatus function is volatile. There is no guarantee that two sequential calls to this function will return the same information. This API call has been made in GetMemoryInfo function of the application attached. I gets the information for memory usage, total physical memory instaled, physical memory available, and total virtual memory. 来源： http://www.codeguru.com/cpp/w-p/system/hardwareinformation/article.php/c2833/
英文版的数据结构CHM
10-25
This book is about the fundamentals of data structures and algorithms--the basic elements from which large and complex software artifacts are built. To develop a solid understanding of a data structure requires three things: First, you must learn how the information is arranged in the memory of the computer. Second, you must become familiar with the algorithms for manipulating the information contained in the data structure. And third, you must understand the performance characteristics of the data structure so that when called upon to select a suitable data structure for a particular application, you are able to make an appropriate decision. This book also illustrates object-oriented design and it promotes the use of common, object-oriented design patterns. The algorithms and data structures in the book are presented in the Java programming language. Virtually all the data structures are presented in the context of a single class hierarchy. This commitment to a single design allows the programs presented in the later chapters to build upon the programs presented in the earlier chapters.
虚拟内存分析
lk_HIT的博客
03-14 487
本篇文章主要目的是对进程的用户地址空间进行一个分析。 先来了解一些概念： 区域，块，页面。 用户地址空间划分为不同的区域，然后区域划分为不同的块，块由页面组成。（如果区域是MEM_FREE,则不存在块的概念） 区域中的块是该区域内连续的页面，并且具有相同的保护属性以及以相同类型的物理存储器作为后备存储器。 分析用户地址空间区域，主要要用到VirtualQueryEx函数，该函数声明如下： DWORD VirtualQueryEx ( HANDLE hProcess, LPCVOID pv.
Windows内存管理与结构体MEMORY_BASIC_INFORMATION
Ginvar的专栏
08-19 3915
原文地址：Windows内存管理与结构体MEMORY_BASIC_INFORMATION作者：Jess23基于32位Windows，摘自http://blog.csdn.net/yeming81/archive/2008/01/16/2046193.aspx   1. 进程地址空间   软件的进程运行于32位系统上，其寻址位也是32位，能表示的空间是232=4G，范围从0x0000 0000~0x
C/C++ 遍历进程内存块
CSDN
07-16 8376
它使用了Windows API函数来遍历指定进程的所有内存块，并输出每个内存块的相关信息。该代码可以帮助了解目标进程的内存布局，以及各个内存块的属性。的函数，用于枚举指定进程的所有内存块。该代码使用Windows API函数实现了遍历指定进程的内存块的功能，并输出了每个内存块的地址、大小和保护属性等信息。使用循环遍历内存块的向量，并输出每个内存块的相关信息，包括基地址、分配基地址、内存块大小、内存块状态、内存保护属性等。在主函数中，创建了一个进程快照句柄，用于获取当前系统中的进程信息。
遍历进程内存
qq_41490873的博客
11-30 979
// inject.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // #include<Windows.h> #include <stdio.h> #define STATUS_UNSUCCESSFUL (0xc0000001) #define STATUS_INFO_LENGTH_MISMATCH 0xc0000004 #define NT_SUCCESS(x) ((x) >= 0) typedef enum _PROCESSINFOCLAS
持久内存开发套件(Persistent Memory Development Kit-PMDK) - pmem.io: PMDK
RToax
11-14 1453
目录 libpmemobj libpmemblk libpmemlog libpmem libpmem2 libvmem libvmmalloc libpmempool pmempool librpmem librpma libpmemset libvmemcache daxio pmreorder PMDK转换 C ++绑定 pmemkv 持久内存开发套件(pmdk) - pmem.io:PMDK 永久性存储器开发套件 https://pmem.io/pmdk/.
Programming_Visual_Basic_NET.pdf
08-15
1.3 An Example Visual Basic .NET Program...................................................14 Chapter 2. The Visual Basic .NET Language..................................................................
linux windows 结构体,Windows内存管理与结构体MEMORY_BASIC_INFORMATION
weixin_39890708的博客
05-04 228
注：基于32位Windows1. 进程地址空间软件的进程运行于32位系统上，其寻址位也是32位，能表示的空间是2的32 =4G，范围从0x0000 0000~0xFFFF FFFF。· NULL指针分区范围：0x0000 0000~0x0000 FFFF作用：保护内存非法访问例子：分配内存时，如果由于某种原因分配不成功，则返回空指针0x0000 0000；当用户继续使用比如改写数据时...
MEMORY_BASIC_INFORMATION中 BaseAddress 和 AllocationBase 区别
asfdasfdsf的专栏
12-01 3094
地址空间在运行中映射为实际的物理页面。   ·        区域 区域指的是上述地址空间中的一片连续地址。区域的大小必须是粒度(64k) 的整数倍，不是的话系统自动处理成整数倍。不同CPU粒度大小是不一样的，大部分都是64K。 区域的状态有：空闲、私有、映射、映像。 在你的应用程序中，申请空间的过程称作保留(预订)，可以用VirtualAlloc；删除空间的过程为释
实现动态库（DLL）之间内存统一管理
qq_39729362的博客
03-27 774
公司里出现了这么个亟待解决的问题，就是项目中的多个动态库在释放时，由于顺序不当产生使用已析构对象野指针引用问题，导致系统崩溃。因此，个人认为解决这个难题的前提是使用统一的动态库负责内存分配与回收。 统一内存管理模块包括：内存分配模块（PMemory.dll），动态库加载模块（PExport.lib），业务模块（PService.exe或dll)，其中 PMemory.dll：为内存的统一分配单元，通过热加载方式使用其new与delete接口。 PExport.lib：封装动态加载与释放PMemory...
拥抱64位Windows
谢启东的专栏
03-25 9562
拥抱64位Windows   还记得640K内存就足够的好日子吗？那记得是什么时候，它显得捉襟见肘了吗？这是一个日新月异的时代，我们发明了各种方法，以在有限的寻址空间内，映射更多的内存：首先，是“扩充内存”（EMM），起初它只是一张硬件“卡”，以64K或128K HASH(0x80b9d4)为界，切换64K的HASH(0x80b9d4)页到DOS寻址空间内；然后，我们又看到了“扩展
【API】获取系统内存所有状态
weixin_33757609的博客
02-02 213
SYSTEM_INFO sysInfo = {0}; GetSystemInfo(&sysInfo); DWORD dwMinAddr = (DWORD)sysInfo.lpMinimumApplicationAddress; DWORD dwMaxAddr = (DWORD)sysInfo.lpMaximumApplicationAddress; ...
VirtualQuery内存保护属性
最新发布
04-17
VirtualQuery是Windows操作系统提供的一个函数，用于查询指定内存区域的保护属性。它可以用来获取指定内存地址的保护属性信息，包括可读、可写、可执行等属性。 VirtualQuery函数的原型如下： ```c++ SIZE_T VirtualQuery( LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, SIZE_T dwLength ); ``` 其中，lpAddress参数指定要查询的内存地址，lpBuffer参数是一个指向MEMORY_BASIC_INFORMATION结构体的指针，用于接收查询结果，dwLength参数指定lpBuffer的大小。 MEMORY_BASIC_INFORMATION结构体定义如下： ```c++ typedef struct _MEMORY_BASIC_INFORMATION { PVOID BaseAddress; PVOID AllocationBase; DWORD AllocationProtect; SIZE_T RegionSize; DWORD State; DWORD Protect; DWORD Type; } MEMORY_BASIC_INFORMATION, *PMEMORY_BASIC_INFORMATION; ``` 其中，AllocationProtect字段表示内存的保护属性。常见的保护属性包括： - PAGE_NOACCESS：禁止对内存进行任何访问。 - PAGE_READONLY：只允许读取内存，不允许写入。 - PAGE_READWRITE：允许读取和写入内存。 - PAGE_EXECUTE：只允许执行内存，不允许读取和写入。 - PAGE_EXECUTE_READ：允许执行和读取内存，不允许写入。 - PAGE_EXECUTE_READWRITE：允许执行、读取和写入内存。 通过调用VirtualQuery函数并解析MEMORY_BASIC_INFORMATION结构体的AllocationProtect字段，可以获取指定内存地址的保护属性信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值