标签: memory-management

3级页表

• 哪个级别包含页面的偏移量？
• 每个级别的页面大小是否相同或不同？

如果第二级和第三级页表的大小为2 ^ 25字节。每个包含2 ^ 9个条目。页表条目的大小为4个字节。其中使用（2 ^ 25-2 ^ 9 * 4）B。

如何使用它，或者将其浪费掉？

4级页表

哪个图可以阐明以下方面的清晰视图：

• MMU
• 页表
• 页表条目
• 虚拟地址
• 物理地址？

我们可以在一个JVM中运行多个进程吗？而且每个进程都应该有自己的内存配额？

我的目标是在有新的http请求进入时启动新进程，并为进程分配一个单独的内存，以便每个用户请求都有自己的内存配额-如果一个人的内存配额已满，则不会打扰其他用户请求。

我该如何实现？

不知道这是否是假设。

我有这样的代码:

var myList = db.Table1.ToList();
/*doing some operations on the list*/
var myList = db.Table2.ToList();
/*again doing some operations on the list*/
var myList = db.Table3.ToList(); // I'm getting out of memory exception here.

我不能按页检索数据,因为我需要一次所有的表.在加载另一个表之前,如何处理(我的意思是释放该列表所公开的空间)列表？谢谢.

编辑:

我加载后,实际上是从myList生成了很多(有时是数千个)子列表.所以我真的需要学习如何释放列表.

编辑2:这是我的完整Stacktrace:

   at System.Collections.Generic.List`1.set_Capacity(Int32 value)
   at System.Collections.Generic.List`1.EnsureCapacity(Int32 min)
   at System.Collections.Generic.List`1.Add(T item)
   at System.Data.Entity.Core.Objects.EntityEntry.TakeSnapshot(Boolean onlySnapshotComplexProperties)
   at System.Data.Entity.Core.Objects.Internal.SnapshotChangeTrackingStrategy.TakeSnapshot(EntityEntry entry)
   at System.Data.Entity.Core.Objects.Internal.EntityWrapper`1.TakeSnapshot(EntityEntry entry)
   at System.Data.Entity.Core.Objects.ObjectStateManager.AddEntry(IEntityWrapper wrappedObject, EntityKey passedKey, EntitySet entitySet, String argumentName, Boolean isAdded)
   at System.Data.Entity.Core.Common.Internal.Materialization.Shaper.HandleEntityAppendOnly[TEntity](Func`2 constructEntityDelegate, EntityKey entityKey, EntitySet entitySet)
   at System.Data.Entity.Core.Common.Internal.Materialization.Coordinator`1.ReadNextElement(Shaper shaper)
   at System.Data.Entity.Core.Common.Internal.Materialization.Shaper`1.SimpleEnumerator.MoveNext()
   at …

我几天前读过这篇文章,我想在Rust中实现这样一个东西的最佳方法是什么.本文建议在每次迭代后使用缓冲区而不是打印字符串.

这是正确的说String::with_capacity()(或Vec)等于mallocC吗？

代码示例:

String::with_capacity(size * 4096)

等于:

char *buf = malloc(size * 4096);

通常,当我创建动态2D数组时,我将首先对行指针进行malloc,然后遍历行和malloc每行.所以,例如:

array = malloc( row_count * sizeof( int* ) );
for( int x = 0; x < row_count; x++ ){
    array[x] = malloc( column_count * sizeof( int ) );
}

完成后,我可以使用如下语法:

data[3][5] = 52;

设置或获取值.这样做的问题是许多malloc都是cpu密集的并且导致许多内存片段,所有这些都必须单独解除分配.另一种方法是将数组分配为单个内存块.但是,如果我这样做,我不能再使用[] []语法来引用数组中的元素,而是我必须做这样的事情:

data[ row_index * column_size + column_index ] = 52;

手动计算连续块中的正确偏移量.有没有办法为数组分配单个内存块,但仍然使用[] []语法？

我正在阅读有关Dispose模式的内容,并了解内存的分配方式.以下是http://codebetter.com/karlseguin/2008/04/28/foundations-of-programming-pt-7-back-to-basics-memory/的引用.

内存分配
....
....
唯一的例外是属于引用类型的值类型-例如User类的Id属性与User类实例本身一起去堆上.

这里也提到了有关Stack Overflow的问题. .net中引用类型内的值类型的内存分配

我的理解是,所有值类型无论它们在何处声明都会进入堆栈.现在这看起来错了.在下面的代码中,i将继续堆; 根据链接不在堆栈上.这是因为MyClass引用类型将转移到堆及其所有值类型.

class MyClass()
{
    int i = 5;
}

好的,所以只有那些不属于类的值类型才能堆栈内存.对？但是,几乎所有像C#这样的Dot Net语言都在课堂上.那究竟什么去堆栈内存？

这个答案解释了什么值类型去堆.

如果是这种情况,堆栈内存上几乎没有甚至几乎没有任何东西.

我怀疑我误会了什么.

如果几乎所有数据都进入堆内存,我不理解堆栈内存的重要性/作用.

请解释.

以下两篇文章以简单的方式解释了很多内存管理.

https://blogs.msdn.microsoft.com/ericlippert/2009/04/27/the-stack-is-an-implementation-detail-part-one/

https://blogs.msdn.microsoft.com/ericlippert/2009/05/04/the-stack-is-an-implementation-detail-part-two/

我正在开发一个几乎没有发现内存泄漏的程序.这段代码实际上已有几十年历史,由一个不知名的人编写.我有返回的功能,char *我想知道我是否需要free内存.
具体来说,我有一个替换字符串中的子字符串的函数,我将指针返回到新malloc编辑的内存.我free是原始的字符串吗？

原始版本:

return(findAndReplace(str, "•",rstring));

新版本:

char *result = findAndReplace(str, "•", rstring);
free(str);
return result;

问题是:我可以100%确定,因为我从其他地方返回的指针已经分配了内存吗？释放内存是否安全(假设它没有在其他任何地方使用)？

编辑:str来自这里:

str = axiom_element_get_text(element, env, messageDataNode);

我是C++的新手,因此这个问题.我在C++中有一个单一链接列表的玩具实现.

template<typename T>
class List {
    template<typename U>
    struct Node {
        U data_;
        Node<U>* next_;

        Node() : data_(0), next_(nullptr) {}
        Node(U data) : data_(data), next_(nullptr) {}
    };

private:
    Node<T>* head_;
    std::size_t size_;

public:
    List() : head_{nullptr}, size_{0} {}

    void insert(const T& item) {
        Node<T>* p(new Node<T>(item));
        if (size_ == 0) {
            head_ = p;
        } else {
            p->next_ = head_;
            head_ = p;
        }
        size_++;
    }
    std::size_t getSize() {
        return size_;
    }

    ~List(){
    while(head_){
        Node<T> p = head_;
        delete(p);
        head_ …

考虑以下C#代码:

IntPtr native = GetNativeError(/* parameters here */);
return new ManagedError(native);

然后客户端代码以下列方式检查错误:

ManagedError err = /* get it with the code above */;
if(err.IsOk()) {
    /* Success */
}

这里的内存分配可以以if语句为代价来保存:

IntPtr native = GetNativeError(/* parameters here */);
if(native == IntPtr.Zero) {
    return null;
} else {
    return new ManagedError(native);
}

然后客户端代码将检查错误,如下所示:

ManagedError err = /* get it with the code above */;
if(err == null) {
    /* Success */
}

我的问题是:哪种方法更快？第一个有额外的内存分配.第二个是附加if声明.

更新:我的意思是,在成功案例中.错误情况很少发生,可以慢.

我在Ubuntu 18.04上有下一个C代码:

#define ID_LEN 5

int main(int argc, char *argv[])
{
    int variableNumberOfElements = 5;
    char **orderedIds;

    *orderedIds = (char *) malloc(variableNumberOfElements * sizeof (char*));
    for (int i = 0; i < variableNumberOfElements; i++)
        orderedIds[i] = (char *) malloc((ID_LEN+1) * sizeof(char));


    for (int i = 0; i < variableNumberOfElements; i++)
        free (orderedIds[i]);

    free(*orderedIds);
    return 0;
}

我以这种方式构建此代码:

g++ -g mymain.c

当我运行这个程序时,我收到一个"分段故障(核心转储)"错误

*orderedIds = (char *) malloc(variableNumberOfElements * sizeof (char*));

哪个是问题？

更新:

分配内存的正确方法是:orderedIds =(char**)malloc(variableNumberOfElements*sizeof(char*));

和:free(orderedIds);

谢谢