javascript

java

python

c#

android

c++

node.js

php

html

jquery

reactjs

ios

css

.net

git

ruby-on-rails

sql

c

string

ruby

内存管理-为什么纯函数式语言不使用引用计数?

在纯功能语言中,数据是不可变的。 使用参考计数时,创建参考周期需要更改已创建的数据。 似乎纯函数式语言可以使用引用计数,而不必担心循环的可能性。 是吗 如果是这样,为什么不呢?

我知道在很多情况下引用计数都比GC慢,但至少可以减少暂停时间。 如果暂停时间不好,可以选择使用引用计数。

trans by 2020-08-03T18:16:55Z

如何在Windows中使用C ++获取内存使用情况

我试图从程序本身中找出我的应用程序正在消耗多少内存。 我要查找的内存使用情况是Windows Task Manager的“进程”选项卡上“内存使用情况”列中报告的数字。

trans by 2020-08-02T19:07:09Z

内存管理-为什么/何时在C语言中使用`intptr_t`进行类型转换?

我有一个关于使用long intmyChar的问题。我观察到,递增的存储器地址(例如,通过手动指针算术)因数据类型而异。 例如,递增char指针会将内存地址加1,而递增int指针会将double值加4、8,长双精度数加16等。

一开始我做了这样的事情:

char myChar, *pChar;
float myFloat, *pFloat;

pChar = &myChar;
pFloat = &myFloat;

printf( "pChar:  %d\n", ( int )pChar );
printf( "pFloat: %d\n", ( int )pFloat );

pChar++;
pFloat++;

printf( "and then after incrementing,:\n\n" );
printf( "pChar:  %d\n", (int)pChar );
printf( "pFloat:    %d\n", (int)pFloat );

可以很好地进行编译和执行,但是XCode在进行类型转换时给了我警告:“从指针投射到不同大小的整数。”

经过一番谷歌搜索和binging(后者是一个词吗?)之后,我看到有人建议使用long int

#include <stdint.h>

...

printf( "pChar:  %ld\n", ( intptr_t )pChar );
printf( "pFloat: %ld\n", ( intptr_t )pFloat );

确实解决了错误。 因此,我认为从现在开始,我应该使用long int进行类型转换指针...但是,在经过一番烦躁之后,我发现可以通过用myFloat替换myChar来解决问题:

printf( "pChar:  %ld\n", ( long int )pChar );
printf( "pFloat: %ld\n", ( long int )pFloat );

所以我的问题是,为什么long int有用,什么时候应该使用? 在这种情况下,似乎是多余的。 显然,myCharmyFloat的内存地址太大而无法容纳在int中...因此将其类型转换为long ints可以解决此问题。

有时对于long int来说,内存地址也太大了吗? 现在,我考虑了一下,我想如果您有> 4GB的RAM,这是可能的,在这种情况下,内存地址可能会超过2 ^ 32-1(无符号长整数的最大值...),但是C在此之前就创建了 可以想象的吧? 还是他们有先见之明?

谢谢!

trans by 2020-08-02T00:10:04Z

增强,shared_ptr与weak_ptr? 什么时候使用?

在我当前的项目中,我相当广泛地使用weak_ptr

最近,我的队友也开始使用weak_ptr,我不知道该使用哪个以及何时使用。

除此之外,如果我想将weak_ptr转换为shared_ptr,该怎么办。将锁锁定在weak_ptr上以创建shared_ptr是否会影响我在其他线程中的代码?

trans by 2020-07-28T17:20:16Z

Linux中的直接内存访问

我正在尝试直接为嵌入式Linux项目访问物理内存,但是我不确定如何最好地指定要使用的内存。

如果我定期引导设备并访问/ dev / mem,则可以轻松地对其几乎任何位置进行读写。 但是,在这种情况下,我正在访问可以轻松分配给任何进程的内存。 我不想做

我的/ dev / mem代码是(删除了所有错误,等等。):

mem_fd = open("/dev/mem", O_RDWR));
mem_p = malloc(SIZE + (PAGE_SIZE - 1));
if ((unsigned long) mem_p % PAGE_SIZE) {
    mem_p += PAGE_SIZE - ((unsigned long) mem_p % PAGE_SIZE);
}
mem_p = (unsigned char *) mmap(mem_p, SIZE, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, mem_fd, BASE_ADDRESS);

这可行。 但是,我想使用没有其他人会碰到的内存。 我试图通过使用mem = XXXm进行引导来限制内核看到的内存量,然后将BASE_ADDRESS设置为高于该值(但低于物理内存),但是它似乎并不能始终访问同一内存。

根据我在网上看到的内容,我怀疑我可能需要一个使用ioremap()或remap_pfn_range()(或两者都使用???)的内核模块(可以),但是我绝对不知道如何使用。 有人可以帮忙吗?

编辑:我想要的是一种始终访问相同物理内存(例如,价值1.5MB)并预留该内存的方式,以便内核不会将其分配给任何其他进程。

我正在尝试重现其他操作系统(没有内存管理)中的系统,从而可以通过链接器在内存中分配空间,并使用类似的方法访问它

*(unsigned char *)0x12345678

编辑2:我想我应该提供更多细节。 该内存空间将用于RAM缓冲区,以用于嵌入式应用程序的高性能日志记录解决方案。 在我们拥有的系统中,没有任何东西可以在软重启期间清除或扰乱物理内存。 因此,如果我将一个位写到物理地址X,然后重新引导系统,则在重新引导后仍将设置相同的位。 已在运行VxWorks的完全相同的硬件上对此进行了测试(此逻辑在不同平台(FWIW)上的Nucleus RTOS和OS20中也能很好地工作)。 我的想法是通过直接寻址物理内存在Linux中尝试相同的事情。 因此,每次启动时获得相同的地址至关重要。

我可能应该澄清一下,这适用于内核2.6.12及更高版本。

编辑3:这是我的代码,首先是内核模块,然后是用户空间应用程序。

要使用它,我先用mem = 95m引导,然后使用insmod foo-module.ko,然后使用mknod mknod / dev / foo c 32 0,然后运行foo-user,在此位置死掉。 在gdb下运行表明它死于分配,尽管在gdb中,我无法取消引用从mmap获得的地址(尽管printf可以)

foo-module.c

#include <linux/module.h>
#include <linux/config.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <asm/io.h>

#define VERSION_STR "1.0.0"
#define FOO_BUFFER_SIZE (1u*1024u*1024u)
#define FOO_BUFFER_OFFSET (95u*1024u*1024u)
#define FOO_MAJOR 32
#define FOO_NAME "foo"

static const char *foo_version = "@(#) foo Support version " VERSION_STR " " __DATE__ " " __TIME__;

static void    *pt = NULL;

static int      foo_release(struct inode *inode, struct file *file);
static int      foo_open(struct inode *inode, struct file *file);
static int      foo_mmap(struct file *filp, struct vm_area_struct *vma);

struct file_operations foo_fops = {
    .owner = THIS_MODULE,
    .llseek = NULL,
    .read = NULL,
    .write = NULL,
    .readdir = NULL,
    .poll = NULL,
    .ioctl = NULL,
    .mmap = foo_mmap,
    .open = foo_open,
    .flush = NULL,
    .release = foo_release,
    .fsync = NULL,
    .fasync = NULL,
    .lock = NULL,
    .readv = NULL,
    .writev = NULL,
};

static int __init foo_init(void)
{
    int             i;
    printk(KERN_NOTICE "Loading foo support module\n");
    printk(KERN_INFO "Version %s\n", foo_version);
    printk(KERN_INFO "Preparing device /dev/foo\n");
    i = register_chrdev(FOO_MAJOR, FOO_NAME, &foo_fops);
    if (i != 0) {
        return -EIO;
        printk(KERN_ERR "Device couldn't be registered!");
    }
    printk(KERN_NOTICE "Device ready.\n");
    printk(KERN_NOTICE "Make sure to run mknod /dev/foo c %d 0\n", FOO_MAJOR);
    printk(KERN_INFO "Allocating memory\n");
    pt = ioremap(FOO_BUFFER_OFFSET, FOO_BUFFER_SIZE);
    if (pt == NULL) {
        printk(KERN_ERR "Unable to remap memory\n");
        return 1;
    }
    printk(KERN_INFO "ioremap returned %p\n", pt);
    return 0;
}
static void __exit foo_exit(void)
{
    printk(KERN_NOTICE "Unloading foo support module\n");
    unregister_chrdev(FOO_MAJOR, FOO_NAME);
    if (pt != NULL) {
        printk(KERN_INFO "Unmapping memory at %p\n", pt);
        iounmap(pt);
    } else {
        printk(KERN_WARNING "No memory to unmap!\n");
    }
    return;
}
static int foo_open(struct inode *inode, struct file *file)
{
    printk("foo_open\n");
    return 0;
}
static int foo_release(struct inode *inode, struct file *file)
{
    printk("foo_release\n");
    return 0;
}
static int foo_mmap(struct file *filp, struct vm_area_struct *vma)
{
    int             ret;
    if (pt == NULL) {
        printk(KERN_ERR "Memory not mapped!\n");
        return -EAGAIN;
    }
    if ((vma->vm_end - vma->vm_start) != FOO_BUFFER_SIZE) {
        printk(KERN_ERR "Error: sizes don't match (buffer size = %d, requested size = %lu)\n", FOO_BUFFER_SIZE, vma->vm_end - vma->vm_start);
        return -EAGAIN;
    }
    ret = remap_pfn_range(vma, vma->vm_start, (unsigned long) pt, vma->vm_end - vma->vm_start, PAGE_SHARED);
    if (ret != 0) {
        printk(KERN_ERR "Error in calling remap_pfn_range: returned %d\n", ret);
        return -EAGAIN;
    }
    return 0;
}
module_init(foo_init);
module_exit(foo_exit);
MODULE_AUTHOR("Mike Miller");
MODULE_LICENSE("NONE");
MODULE_VERSION(VERSION_STR);
MODULE_DESCRIPTION("Provides support for foo to access direct memory");

foo-user.c

#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/mman.h>

int main(void)
{
    int             fd;
    char           *mptr;
    fd = open("/dev/foo", O_RDWR | O_SYNC);
    if (fd == -1) {
        printf("open error...\n");
        return 1;
    }
    mptr = mmap(0, 1 * 1024 * 1024, PROT_READ | PROT_WRITE, MAP_FILE | MAP_SHARED, fd, 4096);
    printf("On start, mptr points to 0x%lX.\n",(unsigned long) mptr);
    printf("mptr points to 0x%lX. *mptr = 0x%X\n", (unsigned long) mptr, *mptr);
    mptr[0] = 'a';
    mptr[1] = 'b';
    printf("mptr points to 0x%lX. *mptr = 0x%X\n", (unsigned long) mptr, *mptr);
    close(fd);
    return 0;
}
trans by 2020-07-25T21:30:45Z

java-存储Graphics对象是一个好主意吗?

我目前正在用Java编写绘画程序,该程序旨在具有灵活而全面的功能。 它源于我前一天晚上写的最后一个项目。 因此,这里有无数的错误,我一直在一一解决(例如,我只能保存将为空的文件,矩形不能正确绘制,而圆圈可以...)。

这次,我一直在尝试向程序添加撤消/重做功能。 但是,我无法“撤消”我所做的事情。 因此,每次启动BufferedImage事件时,我都有一个保存BufferedImages副本的想法。 但是,对于某些分辨率为1920x1080的图像,我发现这样做效率不高:存储它们可能会占用数GB的内存。

之所以不能简单地用背景颜色绘制同一事物来撤消,是因为我有许多不同的笔刷,它们基于BufferedImages进行绘制,并且有许多不同的层(在单个层中)。

然后,我考虑过将用于绘画的BufferedImages对象克隆到BufferedImage

ArrayList<Graphics> revisions = new ArrayList<Graphics>();

@Override
public void mouseReleased(MouseEvent event) {
    Graphics g = image.createGraphics();
    revisions.add(g);
}

我以前没有做过,所以我有几个问题:

  • 通过这样做,我是否仍会浪费无用的内存,例如克隆BufferedImages
  • 我可以采取其他方式吗?
trans by 2020-07-24T14:33:19Z

c-为什么堆MUCH上的内存分配比堆栈上慢?

我被告知很多次了。 但是我不知道为什么...从堆分配内存时会涉及哪些额外费用? 与硬件相关吗? 它与CPU周期有关吗? 这么多的猜测,但没有确切的答案...有人可以给我一些阐述吗?

就像“展开”所说的那样,Heap数据结构比Stack更复杂。 而且我认为,当线程开始运行时,会将一些内存空间分配给该线程作为其堆栈,而进程中的所有线程都将共享堆。 此范例需要一些额外的机制来管理每个线程对共享堆的使用,例如垃圾回收。 我对吗?

trans by 2020-07-22T01:44:42Z

如何在Javascript中为变量分配内存?

我想知道如何在javascript中分配局部变量。在C和C ++中,局部变量存储在堆栈中。 在javascript中是否一样? 还是一切都存储在堆中?

trans by 2020-07-21T04:28:29Z

性能-为Python中的列表保留内存?

使用Python进行编程时,是否可以为列表填充内存,该列表将填充已知数量的项目,以便在构建列表时不会多次重新分配该列表? 我已经在文档中查找了Python列表类型,但没有发现任何可以执行此操作的东西。 但是,这种类型的列表构建出现在我的代码的几个热点中,因此我想使其尽可能高效。

编辑:另外,用Python这样的语言做这样的事情甚至有意义吗? 我是一个相当有经验的程序员,但是对Python还是陌生的,并且仍然对它的工作方式有所了解。 Python是否在内部在单独的堆空间中分配所有对象,从而无法达到尽量减少分配的目的,还是将int,float等原语直接存储在列表中?

trans by 2020-07-20T10:33:22Z

iPhone-使用对象引用的NSArray,我可以显式释放数组中的所有对象还是仅释放数组本身?

我的课程有一个充满对象的NSArray。 在我的dealloc方法中,我可以简单地在NSArray上调用release,还是需要迭代该数组并首先释放所有对象?

trans by 2020-07-20T02:24:29Z

c ++-使std :: vector分配对齐的内存

是否可以使std::vector的自定义结构分配对齐的内存以进一步用SIMD指令处理? 如果可以使用Allocator,是否有人碰巧拥有他可以共享的分配器?

trans by 2020-07-18T22:50:37Z

删除[]是否等于删除?

IP_ADAPTER_INFO *ptr=new IP_ADAPTER_INFO[100];

如果我有空使用

delete ptr;

会导致内存泄漏吗?

这是VS2005生成的反汇编代码

; delete ptr;
0041351D  mov         eax,dword ptr [ptr] 
00413520  mov         dword ptr [ebp-0ECh],eax 
00413526  mov         ecx,dword ptr [ebp-0ECh] 
0041352C  push        ecx  
0041352D  call        operator delete (4111DBh) 
00413532  add         esp,4 

; delete []ptr;
00413535  mov         eax,dword ptr [ptr] 
00413538  mov         dword ptr [ebp-0E0h],eax 
0041353E  mov         ecx,dword ptr [ebp-0E0h] 
00413544  push        ecx  
00413545  call        operator delete[] (4111E5h) 
0041354A  add         esp,4 
trans by 2020-07-17T18:11:14Z

内存管理-是否有理由在程序退出时在C ++中调用delete?

例如,在我的C ++ delete函数中,如果我有一个指向使用堆内存(而不是堆栈内存)的变量的指针,那么在我的应用程序退出后,这个变量是否会自动释放? 我会这样认为。

即使这样,即使您认为在退出时自动释放内存的情况下也永远不会使用堆分配,还是始终删除堆分配是个好习惯吗?

例如,这样做有什么意义吗?

int main(...)
{
    A* a = new A();
    a->DoSomething();
    delete a;
    return 0;
}

我在考虑,也许是在我重构(或其他人重构)该代码并将其放在应用程序中的其他位置的情况下,其中确实需要delete

除了Brian R. Bondy的答案(专门讨论C ++的含义)外,Paul Tomblin也对C特定问题也有一个很好的答案,该问题也涉及C ++析构函数。

trans by 2020-07-14T12:35:07Z

如何在Spark中处理执行程序内存和驱动程序内存?

我对在Spark中处理执行程序内存和驱动程序内存感到困惑。

我的环境设置如下:

  • 内存128 G,16 CPU for 9 VM
  • 几百
  • Hadoop 2.5.0-cdh5.2.0
  • 火花1.1.0

输入数据信息:

  • HDFS的3.5 GB数据文件

为了进行简单开发,我以spark-submit在独立集群模式(8个工作器,20个内核,45.3 G内存)下执行了我的Python代码。现在,我想设置执行程序内存或驱动程序内存以进行性能调整。

从Spark文档中,执行程序内存的定义为

每个执行程序进程要使用的内存量,格式与JVM内存字符串相同(例如512m,2g)。

驱动程序内存如何?

trans by 2020-07-13T01:36:30Z

如何故意删除boost :: shared_ptr?

我有许多boost::shared_ptr对象,在某些时候,我有意要boost::shared_ptr中的一些对象释放一些内存。 (到那时,我知道不再需要指向MyClass的对象了。)我该怎么做?

我想您不能仅使用boost::shared_ptr获得的原始指针来调用boost::shared_ptr

我已经在boost::shared_ptr中看到了功能boost::shared_ptr,但是我不确定如何使用它,并且它旁边还说是实验性的。 (我认为我拥有Boost 1.38。)

也许只是为变量分配一个新的空boost::shared_ptr? 那应该扔掉旧值并删除它。

trans by 2020-07-06T13:13:48Z

javascript-如何正确卸载/销毁VIDEO元素

我正在开发一个实时媒体浏览/播放应用程序,该应用程序在浏览器中使用29534209537930700700对象进行播放(如果有)。

我混合使用了直接的javascript和jQuery,

我特别关心记忆。 该应用程序永远不会在窗口中重新加载,并且用户可以观看许多视频,因此随着时间的推移,内存管理成为一个大问题。 在今天的测试中,我看到内存配置文件随着要加载的每个后续视频流的视频大小而跳跃,并且从未降落到基线。

我已经尝试了以下结果相同的事情:

1-清空包含已创建元素的父容器,例如:

$(container_selector).empty();

2-暂停并删除与“视频”匹配的子项,然后清空父容器:

$(container_selector).children().filter("video").each(function(){
    this.pause();
    $(this).remove();
});
$(container_selector).empty();

还有其他人遇到这个问题吗,还有更好的方法吗?

trans by 2020-07-05T18:55:38Z

内存-python sys.intern的功能是什么,何时使用?

我遇到了有关字典的内存管理的问题,其中提到了intern函数。 它到底有什么作用?何时使用?

举个例子:

如果我有一个名为see的集合,其中包含(string1,string2)形式的元组(我用来检查重复项),则可以存储(intern(string1),intern(string2))来提高性能。 内存还是速度?

trans by 2020-07-04T22:15:20Z

为什么我需要删除[]?

可以说我有一个像这样的函数:

int main()
{
    char* str = new char[10];

    for(int i=0;i<5;i++)
    {
        //Do stuff with str
    }

    delete[] str;
    return 0;
}
  1. 如果仍然要终止程序,为什么需要删除str?如果我要离开的话,我不在乎那记忆是否充满了独角兽,对吗?

  2. 这只是好习惯吗?

  3. 它会带来更深的后果吗?

trans by 2020-07-03T08:49:37Z

.net字符串类交替

由于我正在计划一个将许多数据保存在内存中的应用程序,因此,我希望拥有某种“紧凑”字符串类,至少其中一个包含的字符串格式不得大于该字符串的零终止ASCII版本。

您知道任何这样的字符串类实现吗?它应该具有一些实用程序功能,例如原始的字符串类。

编辑:

我需要对字符串进行排序并能够对其进行扫描,仅提及我将要使用的一些操作。

理想情况下,它将与System.String源兼容,因此基本的搜索和替换操作将优化应用程序的内存占用。

号码:

我可以有10万条记录,每条记录最多包含10个字符串,包含30-60个字符。 所以:

100000x10x60 = 60000000 = 57兆字符。 为什么不使用60兆公羊的内存而不是120兆公羊的内存呢? 操作会更快,一切都会更紧密。

树将用于搜索,但对我打算进行的正则表达式扫描没有帮助。

trans by 2020-06-29T19:32:32Z

性能-内存分配/取消瓶颈?

在典型的实际程序中,内存分配/取消分配有多少瓶颈? 欢迎从通常会影响性能的任何类型的程序中获得答案。 是否足够快地实现了malloc / free /垃圾回收的良好实现,使其在少数情况下仅成为瓶颈,还是大多数性能关键的软件都可以通过尝试减少内存分配量或提高malloc / free /的速度来显着受益。 垃圾回收实现?

注意:我在这里不是在谈论实时内容。 对于性能至关重要,我指的是吞吐量很重要的东西,但延迟不一定。

编辑:尽管我提到了malloc,但此问题并非特定于C / C ++。

trans by 2020-06-28T00:01:03Z

1 2 3 4 5 6 7 8 9 下一页 共9页