标签: allocation

我想将一个数组分配B为相同的形状,并具有与另一个数组相同的下限和上限A.例如,我可以使用

allocate(B(lbound(A,1):ubound(A,1), lbound(A,2):ubound(A,2), lbound(A,3):ubound(A,3)))

但这不仅不优雅,而且对于(甚至)更高维度的阵列也变得非常烦人.

我希望有更多的东西

allocate(B(shape(A)))

哪个不起作用,即使这确实有效,每个维度也会从1开始,这不是我想要的.

有谁知道如何轻松地为任意数组维度轻松分配数组以具有与另一个数组相同的大小和边界？

我有一个Linux内核高CPU消耗的问题,同时在服务器上引导我的java应用程序.这个问题只发生在生产中,在开发服务器上一切都是光速的.

upd9:关于这个问题有两个问题:

1. 怎么解决？- Nominal Animal建议同步并删除所有内容,这确实有帮助.sudo sh -c 'sync ; echo 3 > /proc/sys/vm/drop_caches ;作品.upd12:但确实sync够了.

2. 为什么会这样？ - 它仍然对我开放,我明白将durty页面刷新到磁盘会占用内核CPU和IO时间,这很正常.但是什么是strage,为什么即使用"C"编写的单线程应用程序我在内核空间中加载100%的内核？

由于ref-upd10和ref-upd11,我有一个想法,echo 3 > /proc/sys/vm/drop_caches不需要用缓慢的内存分配来解决我的问题.在启动占用内存的应用程序之前运行`sync'应该足够了.可能会在生产中尝试这个tommorow并在此处发布结果.

upd10:丢失FS缓存页面案例:

1. cat 10GB.fiel > /dev/null然后我执行了
2. sync可以肯定的是,没有durty页面(cat /proc/meminfo |grep ^Dirty显示184kb.
3. 检查cat /proc/meminfo |grep ^Cached我得到:4GB缓存
4. 运行int main(char**)我获得了正常的性能(例如50ms来初始化32MB的已分配数据).
5. 缓存内存减少到900MB
6. 测试总结:我认为linux将用作FS缓存的页面回收到已分配的内存中是没有问题的.

upd11:很多脏页案例.

1. 项目清单

2. 我HowMongoDdWorks用评论的read部分运行我的例子,过了一段时间

3. /proc/meminfo说2.8GB是Dirty和3.6GB Cached. …

是否有任何方法可以覆盖,允许我使用print语句/ pdb /等来跟踪每次分配我的类的实例？虽然取消了一些物体,但我似乎得到了一些从未有过的物体__setstate__或者__init__它们.我尝试覆盖__new__并打印出我所制作的每个对象的id __new__,但我仍然遇到带有永不打印的id的对象.

编辑:这是我的代码,我用来改变(仪表)__new__我的类及其所有超类除了object它自己:

class Allocator:
    def __init__(self, my_class):
       self.my_class = my_class
       self.old_new = my_class.__new__

    def new(self, * args, ** kargs):
        rval = self.old_new(*args, ** kargs)
        #rval = super(self.my_class,cls).__new__(cls)
        print 'Made '+str(self.my_class)+' with id '+str(id(rval))
        return rval

def replace_allocator(cls):
    if cls == object:
        return

    setattr(cls,'__new__',Allocator(cls).new)
    print cls.__base__

    try:
        for parent in cls.__base__:
            replace_allocator(parent)
   except:
        replace_allocator(cls.__base__)

一旦在主脚本中导入,我就在类的父类上调用replace_allocator.我的课程有一个习惯__new__,它也打印出id.

我知道new关键字是在调用类构造函数,但是在哪个阶段我们为类分配内存？

根据我的理解,它应该对应于GCHandle.Alloc(Object)方法,但我无法找到连接.

我正在为应用程序创建一个插件,其中应该由应用程序分配内存并跟踪它.因此,应该以缓冲区的形式从宿主应用程序获取内存句柄,然后将它们返回给应用程序.现在,我正计划使用STL Vectors,我想知道它在内部使用什么样的内存分配.

它是否在内部使用"新"和"删除"功能？如果是这样,我可以用自己的函数重载'new'和'delete'吗？或者我应该创建自己的模板分配器,这对我来说看起来很困难,因为我没有创建自定义模板的经验.

欢迎任何建议/示例代码.可以从这样的应用程序中获取内存句柄

void* bufferH = NULL;

bufferH = MemReg()->New_Mem_Handle(size_of_buffer);
MemReg()->Dispose_Mem_Handle(bufferH); //Dispose it

如果我有这样的功能:

void bla(int size) {
    while(b){
        char tmp[size];
        ......
    }
}

tmp在while循环的每次迭代中被释放,对吗？

如果我写这个函数:

void bla(int size) {
    while(b){
        char* tmp = alloca(size);
        ......
    }
}

tmp在范围结束时或功能结束时被释放？

有人可以告诉我为什么会发生以下事情:

我有2台电脑:

1. 我的工作补偿
2. 服务器

我维护C++程序(msvc 2005 c ++编译),它只在服务器上运行得太慢,但在我的comp上却没有.

我进行了测量(GetThreadTimes等)并且肯定可以说是狭窄的地方 - 它的内存分配(new/malloc).它只发生在服务器上!

我可以声称它是由于内存碎片而发生的,因为第一次服务器程序实例工作正常,只有在数据重新加载到内存(1-1.5百万分配/释放)后才开始在allocs上失去时间.

如果由于两台计算机(我的comp和服务器)上的内存碎片而看到相同的行为,我不会感到惊讶,但我看到的是:1).在我的comp分配上需要约5%的时间(不完全但有些像这样)2).在服务器上,这些分配需要大约75%的时间

怎么会发生这种情况？什么可能会减慢服务器计算机上的C++分配速度,同时它可以用于我的工作站.哪里可能有区别？它可能与OS级内存管理功能有关吗？因为C++级别管理器在两种情况下都是一样的.

以下是两种配置:

1).我的电脑(其中alloc占用约5%):

OS Name:                   Microsoft Windows 7 Enterprise 
OS Version:                6.1.7600 N/A Build 7600
OS Manufacturer:           Microsoft Corporation
OS Configuration:          Member Workstation
OS Build Type:             Multiprocessor Free
Registered Owner:          Windows User
Original Install Date:     16/09/2011, 19:37:43
System Boot Time:          05/04/2013, 11:58:11
System Model:              7304A58
System Type:               x64-based PC
Processor(s):              1 Processor(s) Installed.
                           [01]: Intel64 Family 6 Model 23 Stepping 10 GenuineIntel ~2642 Mhz
Windows Directory:         C:\Windows …

我是学生,我必须研究内存泄漏检测.在许多论文中,他们谈论的是分配环境.我不知道这意味着什么.我找不到任何分配上下文的定义(或翻译,我来自德国).

例如,文章引用(使用机器学习通过内省动态行为建模检测内存泄漏):

使用机器学习的关键思想是通过观察其他类似对象的生命周期来识别泄漏对象.也就是说,当对象产生从其他所谓的相似对象(即具有相同分配上下文的对象)未观察到的高度陈旧时,可以认为该对象已泄露.

要么:

为了解决这个问题,这项工作从先前关于物体寿命预测的研究中获得灵感[4,20].根据这些工作,对象的生命周期与其分配上下文密切相关.由于对象的陈旧性受其生命周期的限制,因此对象陈旧性与分配上下文传递相关.

有人可以尽可能轻松地向我解释一下吗？

编辑:

摘要:

本文通过提出基于机器学习的框架,扩展了基于陈旧性的内存泄漏检测.拟议的框架基于这样一种观点,即在对象的相似性方面可以更好地利用对象的稳定性; 即,如果一个对象显示出从具有相同分配上下文的其他类似对象中未观察到的显着高的陈旧性,则该对象更可能泄露.建议框架的核心部分是堆对象的建模.为此,框架在代表性的应用程序运行期间观察对象的陈旧性.从观察到的数据中,框架生成培训示例,其中还包含假设泄漏的实例.通过机器学习,所提出的框架用基于模型的预测替换了先前研究中使用的容易出错的用户可判断的陈旧性谓词.使用合成和现实示例测试框架.使用SPEC2006基准的合成泄漏工作负荷进行评估表明,所提出的方法实现了基于陈旧度的泄漏检测所允许的最佳精度.此外,通过将 分配上下文合并到模型中,所提出的方法实现了比单独使用对象陈旧时更高的准确度.对现实世界内存泄漏的评估表明,所提出的方法对于以高精度检测先前报告的错误是有效的.

我想使用Instruments Version 7.1(7B91b)来分析我的应用程序.但是当我启动Allocations Instruments时,录制按钮被禁用.我连接了我的iPhone设备(iPhone 6 plus和iOS版本9.1),设备可以使用Xcode进行调试,没有任何问题.

它只是仪器漏洞吗？

似乎,我发现如何在2行代码中轻松获得具有连续内存的普通2D数组:

template<int N, int M>
using Array2D = array<array<int, M>, N>;

让我们来解决简单的任务交换最大和最小的Array2D(有点C++ 17):

template<int N, int M>
void printArray2D(const Array2D<N, M> &arr);

int main() {
    const int N = 5;
    const int M = 5;
    Array2D<N, M> arr;

    // random init of Array2D 
    generate(arr.front().begin(), arr.back().end(), []()->int {
                                                        return rand() % 100;
                                                    });

    printArray2D(arr);

    auto[a, b] = minmax_element(arr.front().begin(), arr.back().end());

    cout << "Swap minimum and maximum: " << *a << " " << *b << endl << endl; …