精华内容
下载资源
问答
  • memory
    千次阅读
    2020-11-02 16:45:05

    [34006.619601] Memory cgroup out of memory: Killed process 6041 (pause) total-vm:1024kB, anon-rss:4kB, file-rss:0kB, shmem-rss:0kB
    [34006.711098] Memory cgroup out of memory: Killed process 6183 (harmonize_log) total-vm:464104kB, anon-rss:7316kB, file-rss:6452kB, shmem-rss:0kB
    [34007.013063] Memory cgroup out of memory: Killed process 10396 (pause) total-vm:1024kB, anon-rss:4kB, file-rss:0kB, shmem-rss:0kB
    [34007.104973] Memory cgroup out of memory: Killed process 10567 (harmonize_log) total-vm:464104kB, anon-rss:9348kB, file-rss:6464kB, shmem-rss:0kB

    rss 的含义:Resident Set Size  // 驻留内存大小(分配给进程,同时在内存中的)
    	pr_err("Killed process %d (%s) total-vm:%lukB, anon-rss:%lukB, file-rss:%lukB, shmem-rss:%lukB\n",
    		task_pid_nr(victim), victim->comm, K(victim->mm->total_vm),
    		K(get_mm_counter(victim->mm, MM_ANONPAGES)),   //Resident anonymous pages
    		K(get_mm_counter(victim->mm, MM_FILEPAGES)),    //Resident file mapping pages
    		K(get_mm_counter(victim->mm, MM_SHMEMPAGES)));   //Resident shared memory pages
    

    /mm/oom_kill.c
    if (oc->chosen && oc->chosen != (void )-1UL) {
    oom_kill_process(oc, !is_memcg_oom(oc) ? “Out of memory” :
    “Memory cgroup out of memory”);
    /

    * Give the killed process a good chance to exit before trying
    * to allocate memory again.
    */
    schedule_timeout_killable(1);
    }

    mem_cgroup_oom_synchronize(bool handle)
    {
    根据当前线程里的current->memcg_in_oom 来做判断; 这个值是怎么来的?
    }

    发生page fault之后会尝试通过kill process来释放内存,防止系统宕机。

    Jun  8 04:19:29 all-in-one-01 kernel: abc.py cpuset=docker-09802cffb93b38777f36ca1bca03c6499cd5b10ea6667a8bc77e74fe75e1b989.scope mems_allowed=0
    Jun  8 04:19:29 all-in-one-01 kernel: CPU: 3 PID: 28006 Comm: abc.py Kdump: loaded Not tainted 4.18.0-147.5.1.el8_1.x86_64 #1
    Jun  8 04:19:29 all-in-one-01 kernel: Hardware name: RDO OpenStack Compute, BIOS 1.11.0-2.el7 04/01/2014
    Jun  8 04:19:29 all-in-one-01 kernel: Call Trace:
    Jun  8 04:19:29 all-in-one-01 kernel: dump_stack+0x5c/0x80
    Jun  8 04:19:29 all-in-one-01 kernel: dump_header+0x6e/0x27a
    Jun  8 04:19:29 all-in-one-01 kernel: oom_kill_process.cold.29+0xb/0x10
    Jun  8 04:19:29 all-in-one-01 kernel: out_of_memory+0x1ba/0x490
    Jun  8 04:19:29 all-in-one-01 kernel: mem_cgroup_out_of_memory+0x49/0x80
    Jun  8 04:19:29 all-in-one-01 kernel: try_charge+0x6fa/0x780
    Jun  8 04:19:29 all-in-one-01 kernel: ? __alloc_pages_nodemask+0xef/0x280
    Jun  8 04:19:29 all-in-one-01 kernel: mem_cgroup_try_charge+0x8b/0x1a0
    Jun  8 04:19:29 all-in-one-01 kernel: mem_cgroup_try_charge_delay+0x1c/0x40
    Jun  8 04:19:29 all-in-one-01 kernel: do_fault+0x8e/0x3e0
    Jun  8 04:19:29 all-in-one-01 kernel: __handle_mm_fault+0x539/0x6b0
    Jun  8 04:19:29 all-in-one-01 kernel: handle_mm_fault+0xda/0x200
    Jun  8 04:19:29 all-in-one-01 kernel: __do_page_fault+0x22b/0x4e0
    Jun  8 04:19:29 all-in-one-01 kernel: do_page_fault+0x32/0x110
    Jun  8 04:19:29 all-in-one-01 kernel: ? async_page_fault+0x8/0x30
    Jun  8 04:19:29 all-in-one-01 kernel: async_page_fault+0x1e/0x30
    Jun  8 04:19:29 all-in-one-01 kernel: RIP: 0033:0x7f82f4815a2a
    
    Nov  4 08:32:16 in-one-01 kernel: containerd invoked oom-killer: gfp_mask=0x6200ca(GFP_HIGHUSER_MOVABLE), nodemask=(null), order=0, oom_score_adj=-999
    Nov  4 08:32:16 in-one-01 kernel: containerd cpuset=/ mems_allowed=0
    Nov  4 08:32:16 in-one-01 kernel: CPU: 8 PID: 5278 Comm: containerd Kdump: loaded Not tainted 4.18.0-147.5.1.el8_1.x86_64 #1
    Nov  4 08:32:16 in-one-01 kernel: Hardware name: RDO OpenStack Compute, BIOS 1.11.0-2.el7 04/01/2014
    Nov  4 08:32:16 in-one-01 kernel: Call Trace:
    Nov  4 08:32:16 in-one-01 kernel: dump_stack+0x5c/0x80
    Nov  4 08:32:16 in-one-01 kernel: dump_header+0x6e/0x27a
    Nov  4 08:32:16 in-one-01 kernel: oom_kill_process.cold.29+0xb/0x10
    Nov  4 08:32:16 in-one-01 kernel: out_of_memory+0x1ba/0x490
                                      inline __alloc_pages_may_oom      如果尝试申请内存 两次,还是没有申请到,就会走到这个函数尝试kill 
    Nov  4 08:32:16 in-one-01 kernel: __alloc_pages_slowpath+0xc0f/0xce0
    Nov  4 08:32:16 in-one-01 kernel: __alloc_pages_nodemask+0x245/0x280
    Nov  4 08:32:16 in-one-01 kernel: alloc_pages_vma+0x74/0x1d0
    Nov  4 08:32:16 in-one-01 kernel: do_fault+0x69/0x3e0
    Nov  4 08:32:16 in-one-01 kernel: __handle_mm_fault+0x539/0x6b0
    Nov  4 08:32:16 in-one-01 kernel: handle_mm_fault+0xda/0x200
    Nov  4 08:32:16 in-one-01 kernel: __do_page_fault+0x22b/0x4e0
    Nov  4 08:32:16 in-one-01 kernel: do_page_fault+0x32/0x110
    Nov  4 08:32:16 in-one-01 kernel: async_page_fault+0x1e/0x30
    Nov  4 08:32:16 in-one-01 kernel: RIP: 0010:__clear_user+0x1a/0x50
    

    #引用:
    https://stackoverflow.com/questions/7880784/what-is-rss-and-vsz-in-linux-memory-management#:~:text=RSS%20is%20the%20Resident%20Set%20Size%20and%20is,It%20does%20include%20all%20stack%20and%20heap%20memory.

    更多相关内容
  • ANTS Memory Profiler 8 安装包+激活工具+教程.zip,ANTS Memory Profiler 8 安装包+激活工具+教程,激活教程.txt,Keygen.exe,DotNETDeveloperBundle.exe
  • spark.executor.memory 包含spark.memory.fraction; spark.memory.fraction 包含 spark.memory.storageFraction; spark 2.4.5 Application Properties Property Name Default Meaning spark.app.name ...

    spark1.6及之后:

    堆内内存:

    spark.executor.memory 包含 spark.memory.fraction;
    spark.memory.fraction 包含 spark.memory.storageFraction;

     

    spark.executor.memory = reserved memory(300MB)+usable memory

    usable memory = unified memory(60%,spark.memory.fraction) + other(40%,1-spark.memory.fraction)

    unified memory = storage memory(50%,spark.memory.storageFraction) + execution memory (1-spark.memory.storageFraction)

     

    堆外内存:

    通过 spark.memory.offHeap.enabled 参数开启,并由 spark.memory.offHeap.size 指定堆外内存的大小,单位是字节(占用的空间划归 JVM OffHeap 内存)。

    堆外内存只区分 Execution 内存和 Storage 内存:

     spark.memory.offHeap.size = storage memory(50%,spark.memory.storageFraction) + execution memory (1-spark.memory.storageFraction)

     

    storage memory = 堆内storage memory + 堆外storage memory

    execution memory = 堆内execution memory + 堆外execution memory

     

    spark 2.4.5

    Application Properties

    Property NameDefaultMeaning
    spark.app.name(none)The name of your application. This will appear in the UI and in log data.
    spark.driver.cores1Number of cores to use for the driver process, only in cluster mode.
    spark.driver.maxResultSize1gLimit of total size of serialized results of all partitions for each Spark action (e.g. collect) in bytes. Should be at least 1M, or 0 for unlimited. Jobs will be aborted if the total size is above this limit. Having a high limit may cause out-of-memory errors in driver (depends on spark.driver.memory and memory overhead of objects in JVM). Setting a proper limit can protect the driver from out-of-memory errors.
    spark.driver.memory1gAmount of memory to use for the driver process, i.e. where SparkContext is initialized, in the same format as JVM memory strings with a size unit suffix ("k", "m", "g" or "t") (e.g. 512m2g).
    Note: In client mode, this config must not be set through the SparkConf directly in your application, because the driver JVM has already started at that point. Instead, please set this through the --driver-memory command line option or in your default properties file.
    spark.driver.memoryOverheaddriverMemory * 0.10, with minimum of 384The amount of off-heap memory to be allocated per driver in cluster mode, in MiB unless otherwise specified. This is memory that accounts for things like VM overheads, interned strings, other native overheads, etc. This tends to grow with the container size (typically 6-10%). This option is currently supported on YARN and Kubernetes.
    spark.executor.memory1gAmount of memory to use per executor process, in the same format as JVM memory strings with a size unit suffix ("k", "m", "g" or "t") (e.g. 512m2g).
    spark.executor.pyspark.memoryNot setThe amount of memory to be allocated to PySpark in each executor, in MiB unless otherwise specified. If set, PySpark memory for an executor will be limited to this amount. If not set, Spark will not limit Python's memory use and it is up to the application to avoid exceeding the overhead memory space shared with other non-JVM processes. When PySpark is run in YARN or Kubernetes, this memory is added to executor resource requests. NOTE: Python memory usage may not be limited on platforms that do not support resource limiting, such as Windows.
    spark.executor.memoryOverheadexecutorMemory * 0.10, with minimum of 384The amount of off-heap memory to be allocated per executor, in MiB unless otherwise specified. This is memory that accounts for things like VM overheads, interned strings, other native overheads, etc. This tends to grow with the executor size (typically 6-10%). This option is currently supported on YARN and Kubernetes.

     

    Memory Management

    Property NameDefaultMeaning
    spark.memory.fraction0.6Fraction of (heap space - 300MB) used for execution and storage. The lower this is, the more frequently spills and cached data eviction occur. The purpose of this config is to set aside memory for internal metadata, user data structures, and imprecise size estimation in the case of sparse, unusually large records. Leaving this at the default value is recommended. For more detail, including important information about correctly tuning JVM garbage collection when increasing this value, see this description.
    spark.memory.storageFraction0.5Amount of storage memory immune to eviction, expressed as a fraction of the size of the region set aside by spark.memory.fraction. The higher this is, the less working memory may be available to execution and tasks may spill to disk more often. Leaving this at the default value is recommended. For more detail, see this description.
    spark.memory.offHeap.enabledfalseIf true, Spark will attempt to use off-heap memory for certain operations. If off-heap memory use is enabled, then spark.memory.offHeap.size must be positive.
    spark.memory.offHeap.size【堆外内存】0The absolute amount of memory in bytes which can be used for off-heap allocation. This setting has no impact on heap memory usage, so if your executors' total memory consumption must fit within some hard limit then be sure to shrink your JVM heap size accordingly. This must be set to a positive value when spark.memory.offHeap.enabled=true.
    spark.memory.useLegacyModefalseWhether to enable the legacy memory management mode used in Spark 1.5 and before. The legacy mode rigidly partitions the heap space into fixed-size regions, potentially leading to excessive spilling if the application was not tuned. The following deprecated memory fraction configurations are not read unless this is enabled: spark.shuffle.memoryFraction
    spark.storage.memoryFraction
    spark.storage.unrollFraction
    spark.shuffle.memoryFraction0.2(deprecated) This is read only if spark.memory.useLegacyMode is enabled. Fraction of Java heap to use for aggregation and cogroups during shuffles. At any given time, the collective size of all in-memory maps used for shuffles is bounded by this limit, beyond which the contents will begin to spill to disk. If spills are often, consider increasing this value at the expense of spark.storage.memoryFraction.
    spark.storage.memoryFraction0.6(deprecated) This is read only if spark.memory.useLegacyMode is enabled. Fraction of Java heap to use for Spark's memory cache. This should not be larger than the "old" generation of objects in the JVM, which by default is given 0.6 of the heap, but you can increase it if you configure your own old generation size.
    spark.storage.unrollFraction0.2(deprecated) This is read only if spark.memory.useLegacyMode is enabled. Fraction of spark.storage.memoryFraction to use for unrolling blocks in memory. This is dynamically allocated by dropping existing blocks when there is not enough free storage space to unroll the new block in its entirety.
    spark.storage.replication.proactivefalseEnables proactive block replication for RDD blocks. Cached RDD block replicas lost due to executor failures are replenished if there are any existing available replicas. This tries to get the replication level of the block to the initial number.
    spark.cleaner.periodicGC.interval30minControls how often to trigger a garbage collection.

    This context cleaner triggers cleanups only when weak references are garbage collected. In long-running applications with large driver JVMs, where there is little memory pressure on the driver, this may happen very occasionally or not at all. Not cleaning at all may lead to executors running out of disk space after a while.
    spark.cleaner.referenceTrackingtrueEnables or disables context cleaning.
    spark.cleaner.referenceTracking.blockingtrueControls whether the cleaning thread should block on cleanup tasks (other than shuffle, which is controlled by spark.cleaner.referenceTracking.blocking.shuffle Spark property).
    spark.cleaner.referenceTracking.blocking.shufflefalseControls whether the cleaning thread should block on shuffle cleanup tasks.
    spark.cleaner.referenceTracking.cleanCheckpointsfalseControls whether to clean checkpoint files if the reference is out of scope.

    http://spark.apache.org/docs/2.4.5/configuration.html#available-properties

     

    • spark.memory.fraction expresses the size of M as a fraction of the (JVM heap space - 300MB) (default 0.6). The rest of the space (40%) is reserved for user data structures, internal metadata in Spark, and safeguarding against OOM errors in the case of sparse and unusually large records.
    • spark.memory.storageFraction expresses the size of R as a fraction of M (default 0.5). R is the storage space within M where cached blocks immune to being evicted by execution.

    The value of spark.memory.fraction should be set in order to fit this amount of heap space comfortably within the JVM’s old or “tenured” generation. See the discussion of advanced GC tuning below for details.

    http://spark.apache.org/docs/2.4.5/tuning.html#memory-management-overview

     

    首先我们知道在执行 Spark 的应用程序时,Spark 集群会启动 Driver 和 Executor 两种 JVM 进程,前者为主控进程,负责创建 Spark 上下文,提交 Spark 作业(Job),并将作业转化为计算任务(Task),在各个 Executor 进程间协调任务的调度,后者负责在工作节点上执行具体的计算任务,并将结果返回给 Driver,同时为需要持久化的 RDD 提供存储功能。由于 Driver 的内存管理相对来说较为简单,本文主要对 Executor 的内存管理进行分析,下文中的 Spark 内存均特指 Executor 的内存。

    另外,Spark 1.6 之前使用的是静态内存管理 (StaticMemoryManager) 机制,StaticMemoryManager 也是 Spark 1.6 之前唯一的内存管理器。在 Spark1.6 之后引入了统一内存管理 (UnifiedMemoryManager) 机制,UnifiedMemoryManager 是 Spark 1.6 之后默认的内存管理器,1.6 之前采用的静态管理(StaticMemoryManager)方式仍被保留,可通过配置 spark.memory.useLegacyMode 参数启用。这里仅对统一内存管理模块 (UnifiedMemoryManager) 机制进行分析。

    Executor内存总体布局

    默认情况下,Executor不开启堆外内存,因此整个 Executor 端内存布局如下图所示: 

    我们可以看到在Yarn集群管理模式中,Spark 以 Executor Container 的形式在 NodeManager 中运行,其可使用的内存上限由 yarn.scheduler.maximum-allocation-mb 指定,我们称之为 MonitorMemory。

    整个Executor内存区域分为两块:

    1、JVM堆外内存

    大小由 spark.yarn.executor.memoryOverhead 参数指定。默认大小为 executorMemory【由spark.executor.memory配置】 * 0.10, with minimum of 384m。

    此部分内存主要用于JVM自身,字符串, NIO Buffer(Driect Buffer)等开销。此部分为用户代码及Spark 不可操作的内存,不足时可通过调整参数解决。

    The amount of off-heap memory (in megabytes) to be allocated per executor. This is memory that accounts for things like VM overheads, interned strings, other native overheads, etc. This tends to grow with the executor size (typically 6-10%).

    2、堆内内存(ExecutorMemory)

    大小由 Spark 应用程序启动时的 –executor-memory 或 spark.executor.memory 参数配置,即JVM最大分配的堆内存 (-Xmx)。Spark为了更高效的使用这部分内存,对这部分内存进行了逻辑上的划分管理。我们在下面的统一内存管理会详细介绍。

    NOTES

    对于Yarn集群,存在: ExecutorMemory + MemoryOverhead <= MonitorMemory,若应用提交之时,指定的 ExecutorMemory 与 MemoryOverhead 之和大于 MonitorMemory,则会导致 Executor 申请失败;若运行过程中,实际使用内存超过上限阈值,Executor 进程会被 Yarn 终止掉 (kill)。

    统一内存管理

    Spark 1.6之后引入了统一内存管理,包括了堆内内存 (On-heap Memory) 和堆外内存 (Off-heap Memory) 两大区域,下面对这两块区域进行详细的说明。

    堆内内存 (On-heap Memory)

    默认情况下,Spark 仅仅使用了堆内内存。Spark 对堆内内存的管理是一种逻辑上的“规划式”的管理,Executor 端的堆内内存区域在逻辑上被划分为以下四个区域:

    spark-memory-overview

     

    1. 执行内存 (Execution Memory) : 主要用于存放 Shuffle、Join、Sort、Aggregation 等计算过程中的临时数据;
    2. 存储内存 (Storage Memory) : 主要用于存储 spark 的 cache 数据,例如RDD的缓存、unroll数据;
    3. 用户内存(User Memory): 主要用于存储 RDD 转换操作所需要的数据,例如 RDD 依赖等信息;
    4. 预留内存(Reserved Memory): 系统预留内存,会用来存储Spark内部对象。

    下面的图对这个四个内存区域的分配比例做了详细的描述:

    spark-in-heap-memory-overview

     

    1、存储内存 (Storage Memory)

    主要用于存储 spark 的 cache 数据,例如 RDD 的缓存、广播(Broadcast)数据、和 unroll 数据。内存占比为 UsableMemory * spark.memory.fraction * spark.memory.storageFraction,Spark 2+ 中,默认初始状态下 Storage Memory 和 Execution Memory 均约占系统总内存的30%(1 * 0.6 * 0.5 = 0.3)。在 UnifiedMemory 管理中,这两部分内存可以相互借用,具体借用机制我们下一小节会详细介绍。

    2、执行内存 (Execution Memory)

    主要用于存放 Shuffle、Join、Sort、Aggregation 等计算过程中的临时数据。内存占比为 UsableMemory * spark.memory.fraction * (1 - spark.memory.storageFraction),Spark 2+ 中,默认初始状态下 Storage Memory 和 Execution Memory 均约占系统总内存的30%(1 * 0.6 * (1 - 0.5) = 0.3)。在 UnifiedMemory 管理中,这两部分内存可以相互借用,具体借用机制我们下一小节会详细介绍。

    3、其他/用户内存 (Other/User Memory) : 主要用于存储 用户定义的数据结构或spark内部元数据。内存占比为 UsableMemory * (1 - spark.memory.fraction),在Spark2+ 中,默认占可用内存的40%(1 * (1 - 0.6) = 0.4)。

    4、预留内存 (Reserved Memory) 

    系统预留内存,作用与Other相同,用来存储 用户定义的数据结构或spark内部元数据。其大小在代码中是写死的,其值等于 300MB,这个值是不能修改的(如果在测试环境下,我们可以通过 spark.testing.reservedMemory 参数进行修改);如果Executor分配的内存小于 1.5 * 300 = 450M 时,Executor将无法执行。

    其中,usableMemory = executorMemory - reservedMemory,这个就是 Spark 可用内存。

    NOTES

    1、为什么设置300M预留内存

    统一内存管理最初版本other这部分内存没有固定值 300M 设置,而是和静态内存管理相似,设置的百分比,最初版本占 25%。百分比设置在实际使用中出现了问题,若给定的内存较低时,例如 1G,会导致 OOM,具体讨论参考这里 Make unified memory management work with small heaps。因此,other这部分内存做了修改,先划出 300M 内存。

    2、spark.memory.fraction 由 0.75 降至 0.6

    spark.memory.fraction 最初版本的值是 0.75,很多分析统一内存管理这块的文章也是这么介绍的,同样的,在使用中发现这个值设置的偏高,导致了 gc 时间过长,spark 2.0 版本将其调整为 0.6,详细谈论参见 Reduce spark.memory.fraction default to avoid overrunning old gen in JVM default config

     

    堆外内存 (Off-heap Memory)

    Spark 1.6 开始引入了 Off-heap memory (详见SPARK-11389)。这种模式不在 JVM 内申请内存,而是调用 Java 的 unsafe 相关 API 进行诸如 C 语言里面的 malloc() 直接向操作系统申请内存。这种方式下 Spark 可以直接操作系统堆外内存,减少了不必要的内存开销,以及频繁的 GC 扫描和回收,提升了处理性能。另外,堆外内存可以被精确地申请和释放,而且序列化的数据占用的空间可以被精确计算,所以相比堆内内存来说降低了管理的难度,也降低了误差。,缺点是必须自己编写内存申请和释放的逻辑。【钨丝计划】

    默认情况下Off-heap模式的内存并不启用,我们可以通过 spark.memory.offHeap.enabled 参数开启,并由 spark.memory.offHeap.size 指定堆外内存的大小,单位是字节(占用的空间划归 JVM OffHeap 内存)。

    如果堆外内存被启用,那么 Executor 内将同时存在堆内和堆外内存,两者的使用互补影响,这个时候 Executor 中的 Execution 内存是堆内的 Execution 内存和堆外的 Execution 内存之和,同理,Storage 内存也一样。其内存分布如下图所示:

    spark-off-heap-memory-overview

     

    相比堆内内存,堆外内存只区分 Execution 内存和 Storage 内存:

    1、存储内存 (Storage Memory)

    内存占比为 maxOffHeapMemory * spark.memory.storageFraction,Spark 2+ 中,默认初始状态下 Storage Memory 和 Execution Memory 均约占系统总内存的50%(1 * 0.5 = 0.5)。在 UnifiedMemory 管理中,这两部分内存可以相互借用,具体借用机制我们下一小节会详细介绍。

    2、执行内存 (Execution Memory)

    内存占比为 maxOffHeapMemory * (1 - spark.memory.storageFraction),Spark 2+ 中,默认初始状态下 Storage Memory 和 Execution Memory 均约占系统总内存的50%(1 * (1 - 0.5) = 0.5)。在 UnifiedMemory 管理中,这两部分内存可以相互借用,具体借用机制我们下一小节会详细介绍。

    转自 http://arganzheng.life/spark-executor-memory-management.html 【特别好!!】

    ---------------------------

    一、新旧内存管理

    1、旧有(1.6版本之前)的内存管理
    概念上,内存空间被分成了三块独立的区域,每块区域的内存容量是按照JVM堆大小的固定比例进行分配的:

    Execution:在执行shuffle、join、sort和aggregation时,用于缓存中间数据。通过spark.shuffle.memoryFraction进行配置,默认为0.2。
    Storage:主要用于缓存数据块以提高性能,同时也用于连续不断地广播或发送大的任务结果。通过`spark.storage.memoryFraction进行配置,默认为0.6。
    Other:这部分内存用于存储运行Spark系统本身需要加载的代码与元数据,默认为0.2。
    无论是哪个区域的内存,只要内存的使用量达到了上限,则内存中存储的数据就会被放入到硬盘中,从而清理出足够的内存空间。这样一来,由于与执行或存储相关的数据在内存中不存在,就会影响到整个系统的性能,导致I/O增长,或者重复计算。

    2、1.6版本之后

    到了1.6版本,Execution Memory和Storage Memory之间支持跨界使用。当执行内存不够时,可以借用存储内存,反之亦然。
    1.6版本的实现方案支持借来的存储内存随时都可以释放,但借来的执行内存却不能如此。
    新的版本引入了新的配置项:
    spark.memory.fraction(默认值为0.6):用于设置存储内存和执行内存占用堆内存的比例。若值越低,则发生spill和evict的频率就越高。注意,设置比例时要考虑Spark自身需要的内存量。
    spark.memory.storageFraction(默认值为0.5):显然,这是存储内存所占spark.memory.fraction设置比例内存的大小。当整体的存储容量超过该比例对应的容量时,缓存的数据会被evict。
    spark.memory.useLegacyMode(默认值为false):若设置为true,则使用1.6版本前的内存管理机制。此时,如下五项配置均生效:

    spark.storage.memoryFraction
    spark.storage.safetyFraction
    spark.storage.unrollFraction
    spark.shuffle.memoryFraction
    spark.shuffle.safetyFraction

    转自:https://blog.csdn.net/Evankaka/article/details/63683728

    展开全文
  • memory学习

    千次阅读 2021-07-05 22:07:52
    Memory种类 Memory用来存储和读写的大量的二进制数据。按功能上分类,基本可以分为两大类:只读存储器(ROM)和随机存取存储器(RAM)。ROM只能读,不能写;RAM既能读又能写。RAM具有易失性。断电以后,RAM中保存的...

    Memory种类

    Memory用来存储和读写的大量的二进制数据。按功能上分类,基本可以分为两大类:只读存储器(ROM)和随机存取存储器(RAM)。ROM只能读,不能写;RAM既能读又能写。RAM具有易失性。断电以后,RAM中保存的数据将全部丢失;而ROM中的数据则可以长久保存。

    RAM可以分为常用的SRAM和DRAM。SRAM是静态的存储器,存储单元是一个触发器,有0,1两个稳态;DRAM是动态的存储器,比SRAM要复杂一些,因为它会利用电容器存储电荷来保存0或1,需要在存储数据的过程中需要对于存储的信息不停的刷新。

    Memory结构

    存储器内部结构一般由存储阵列,地址译码器和输出控制电路组成。我们把存储阵列以外的电路都称为外围电路(Periphery)。

    存储阵列是memory的核心区域,它有许多存储单元组成,每个存储单元存放一位二值数据。每次读出一组数据,称为一组字。一个字中所含的位数称为字长(Bit)。为了区别各个不同的字,给每个字赋予一个编号,称为地址,由译码器将地址代码转译。地址单元个数就是字数(Depth),用N表示,数值为2n次方,n为地址码的位数。

    实际运用中,我们经常以字数(Depth)和字长(Bit)的乘积来表示存储器的容量。如下图中的ROM容量为28  X 1,有256个字,字长为1位,总共256个存储单元。容量越大,意味着能存储的数据越多。

    640?wx_fmt=jpeg

    Memory配置

    一般foundry提供的memory databook上,会有以下参数指标,然后我们根据上面这个memory来对照一下这些指标。

    WL: Physical Word Lines 字线  16条

    BL:Physical Bit Lines  位线   16条

    WD: Word Depth (WL * MUX)字数   16*16 =256

    BIT: I/O Data Width (BL/MUX)字长   16/16 =1

    Granularity:步长,WD或者BIT间隔的大小,只能按步长整数倍增加

    BANK:分块,在Memory中,如果Bit line很长,会造成它的充放电速度很慢,导致memory的频率很低,这时,我们会将存储阵列分成N个bank来降低Bit line的长度

    SEG: 分段,在Memory中,如果Word line很长,会影响它的性能,所以按Word line方向,把存储阵列分成N个segment.

     BANK和SEG图示如下:

    640?wx_fmt=jpeg

    C64,C128,C256: Cell per bit line。每条bit line上挂的存储单元个数,经常有64,128,256等不同数字,该数值越大,表示配置的memory速度越慢,但是面积会越小;数值越小,表示配置的memory速度越快,但是面积会越大。

    通常,大家还会看到类型HD,HC,HP等缩写,这些都是表征不同类型Bitcell和外围电路(Periphery)组成的。 

    HD:High Density Bitcell ,面积较小

    HC:High Current Bitcell 高工作电流,access time较小

    HP:High Performance Periphery  ,速度快

    LP:Low-Power Periphery ,功耗较小

    ULP:Ultra-Low Power Periphery,超低功耗

    ULL:Ultra-Low Leakage Periphery,超低漏电流

    Memory端口

    Memory端口类型也有很大的区别,通常分为单口和双口。

    Register file速度快,面积小,容量小。小容量下,我们应该优先选择Register file,它可以分为以下三种:

    Single port(1RW): 一个端口,只能执行读或者写操作

    Two port(1R/1W):2个端口,一个端口读,另一个端口写,可以独立不同的时钟频率

    Pseudo two port(1R/1W):2个端口,一个端口读,另一个端口写,只有一个时钟。

    三个种类的示意图如下:

    640?wx_fmt=jpeg

    SRAM包含更多的模块,容量可以做得更大,可以拥有更多的bank,速度较慢,面积更大。大容量需求时,可以优先考虑SRAM。

    SRAM按端口类型也可以分为以下三种:

    Single port(1RW): 一个端口,只能执行读或者写操作

    Dual port(2RW):2个端口,两个端口可以同时读写,可以独立不同的时钟频率

    Pseudo two port(1R/1RW):2个端口,一个端口读,另一个端口可以读可以写,只有一个时钟。

    示意图如下:

    举例分析:

    对于一个256X64M4的memroy,MUX为4,字数WD为256,字线WL为256/4=64,字长BW为64,位线为64x4=256。

    ———————————————

    原文链接:https://blog.csdn.net/Tao_ZT/article/details/102456813

    展开全文
  • oracle memory_max_target memory_target

    从oracle 11g 开始提供了memory_max_target、memory_target两个新的内存管理参数,进一步简化了Oracle的内存管理。

    这两个参数和原来的sga_max_size、sga_target、pga_aggregate_target的关系经过查看文档和实际测试如下:

    参考文档

    MEMORY_TARGETicon-default.png?t=M1FBhttps://docs.oracle.com/cd/E57185_01/HFMAD/apbs09s03s03.html

    Total Memory Sizing (MEMORY_TARGET)icon-default.png?t=M1FBhttps://docs.oracle.com/cd/E57185_01/HFMAD/apbs09s04s01.html

    1、如果设置memory_max_target、memory_target为0,则关闭内存自动管理,内存的管理方式与oracle 10g保持一致

    2、如果设置memory_max_target、memory_target为非0,则打开内存自动管理。这时候根据官方建议sga_target、pga_aggregate_target应当设置为0。这个时候如果sga_max_size也设置为了0,那么在数据库启动的时候,sga_max_size会自动设置为memory_target*0.6,也就是说sga_target最大不会超过memory_target*0.6,如果sga_max_size设置为了一个数值,那么在数据库启动的时候,sga会分配为memory_target*0.6,pga会分配为memory_target*0.4,后期会根据实际使用情况自动进行调整,但是不会超过sga_max_size。

    比如:memory_target=100G,人为将alter system set sga_max_size=0 scope=spfile;那么数据库启动的时候sga_max_size会被设置为60G,也就是说sga运行期间不会超过60G。如果alter system set sga_max_size=90G scope=spfile;那么虽然数据库启动的时候sga分配成了60G,但是数据库运行期间会自动进行调整,但最高不超过90G

    3、内存的查看及优化建议可以通过下面的三个语句进行查询

    select * from v$memory_target_advice order by memory_size;
    select * from v$pga_target_advice order by pga_target_for_estimate;
    select * from v$sga_target_advice order by sga_size;

    展开全文
  • k8s(十)— 资源限制(cpu、memory

    千次阅读 2022-04-17 22:07:41
    v1 kind: Pod metadata: name: memory-demo spec: containers: - name: memory-demo image: nginx resources: requests: memory: 100Mi cpu 和memory 符合资源限制要求 cpu: 0.1 limits: memory: 200Mi cpu: 0.5 ...
  • Shared Memory

    千次阅读 2018-04-16 13:42:59
    1、引言 在global memory部分,数据对齐和连续是提升性能的很重要的因素,当使用L1 cache的时候,对齐问题不再是问题,但是非连续的获取内存依然会降低性能。依赖于算法本质,某些情况下,非连续访问是不可避免的。...
  • SAP Memory & ABAP Memory超级详细解析

    千次阅读 2020-04-23 13:59:12
    以前做enhancement的时候用过parameter id 和 memory id, 但很多其他语法用法我是没接触过的, 今天看了Palm同鞋做的文档SAP Memory & ABAP Memory, 做了一些测试, 本文几乎所有内容来自Palm同鞋的文档. 1、先...
  • MemoryDB,选择搜索结果的第一个选项 可以看到整体的界面,点击开始使用即可: MemoryDB 上手教程 Amazon MemoryDB for Redis 是一项与 Redis 兼容、极具持久性的内存数据库服务,可实现超快性能。为具有微服务架构...
  • SciTech.NET.Memory.Profiler.v4.0.114.安装_注册机

    千次下载 热门讨论 2013-01-08 11:37:20
    NET Memory Profiler-找到内存泄漏并优化内存使用针对C#,VB.Net, 或其它.Net程序。 包含安装+注册机
  • 查看原生内存信息:jcmd process_id VM.native_memory summary jcmd <pid> VM.native_memory [summary | detail | baseline | summary.diff | detail.diff | shutdown] 1.执行命令:jcmd <pid> VM....
  • am-memory,driver-memory,executor-memory

    千次阅读 2019-10-17 11:12:11
    先搞清几个概念: spark 提交任务方式 spark 提交任务有两种...yarn-cluster的ApplicationMaster在任一一台NodeManager上启动,此方式ApplicationMaster包含driver,am的内存:driver.memory+driver.memoryOverhea...
  • 当安装虚拟机时系统时没有设置swap大小或设置内存太小,编译程序会出现virtual memory exhausted: Cannot allocate memory的问题,可以用swap扩展内存的方法。二、解决方法 在执行free -m的是时候提示Cannot ...
  • JVM Heap Memory和Native Memory

    千次阅读 2018-12-07 11:46:00
    JVM管理的内存可以总体划分为两部分:Heap Memory和Native Memory。前者我们比较熟悉,是供Java应用程序使用的;后者也称为C-Heap,是供JVM自身进程使用的。Heap Memory及其内部各组成的大小可以通过JVM的一系列...
  • bootstrap.memory_lock

    千次阅读 2022-03-15 17:19:46
    实现这一目标的一种方法是将bootstrap.memory_lock设置为true。 要使此设置有效,首先需要配置其他系统设置。有关如何正确设置内存锁定的更多详细信息,请参阅启用bootstrap.memory_lock。 bootstrap.memory_lock: ...
  • python Memory Error的解决方法

    千次阅读 2021-10-31 17:43:04
      在用python处理数据处理的时候有时候会碰到较大的数据集,可能会出现Memory Error 的问题,经过我的尝试,总结如下几个方案: 1. 修改数据类型的长度   修改数据类型的长度,可以对数据进行内存压缩,从而减少...
  • lucene-memory-3.6.2.jar

    热门讨论 2014-05-21 15:05:22
    lucene-memory-3.6.2.jar包,需要的拿走
  • 文章目录1.Relaxed ordering2.Release-Acquire ordering3....前面介绍了c++里一共有六种memory order,要达到数据同步的效果,需要进行组合使用,我们可以在两个地方指定memory order,一是atomic变量(原子变量)...
  • 目录1.c++的六种memory_ordermemory_order_relaxedmemory_order_consumememory_order_acquirememory_order_releasememory_order_acq_relmemory_order_seq_cstSequenced-beforeCarries dependencyModification ...
  • mysql Out of memory的错误解决

    千次阅读 2021-01-19 11:17:46
    这几天碰到这个错误。至于我改的这几个值是不是正确的...Out of memory (Needed 16777224 bytes)的错误解决看看手册:[url]http://dev.mysql.com/doc/refman/5.1/en/memory-storage-engine.html[/url]开始我更改了qu...
  • Memory Compiler

    千次阅读 2020-12-09 15:15:30
    memory分为两类RAM和ROM。RAM根据读写端口个数又分为三类即单端口RAM(SP),伪双端口RAM(TP)和双端口RAM(DP)。SP只存在一个时钟和一套读写端口,读写复用地址总线,读写不能同时操作。TP存在两个时钟(读、写)...
  • 目录 引言 cpu架构 std::memory_order_relaxed(宽松内存序)介绍 示例代码 引言 本文是讲解C++内存序一列文章中的一部分,主要讲解宽松内存序的理解和使用。 本部分将从如下三方面讲解: 一个粗略的可能存在的现代cpu...
  • calldata memory storage 区别详细讲解

    千次阅读 2022-03-28 16:29:27
    首先明确一点calldata memory storage 都是用来修饰饮用类型的。 强制指定的数据位置: • 外部函数(就是说使用external关键字的函数)的参数(不包括返回参数): calldata,效果跟 memory 差不多 • 状态变量...
  • flink 运行任务突然报错,org.apache.flink.configuration.IllegalConfigurationException: TaskManager memory configuration failed: Derived JVM Overhead size (2.500gb (2684354560 bytes)) is not in ...
  • 文章目录AMM参数AMM配置11g MEMORY_TARGET 参数对SGA 和PGA的影响 标签(空格分隔): Oracle 基础概念 Oracle在简化内存管理方面过去几年做了巨大的努力,从Oracle 9i通过PGA_AGGREGATE_TARGET参数实现PGA自动管理...
  • 今天突然发现es报错,无法正常启动,报错信息如下: Exception in thread "main" java.lang.RuntimeException: starting java failed with [1] ...# Native memory allocation (mmap) failed to map 621595852
  • 今天在给一个可执行c程序的entry point address设置断点的时候,出现了Cannot access memory at address的错误(为了测试为什么gcc -e指定一个函数foo先运行的时候,foo函数用return会出现core dump的错误,这个后面...
  • 本人刚刚入手cv,见解浅陋,如有不对请多多包含。 根据从网上查找的资料,遇到这种情况一般有以下几种解决方法: 1.在程序运行的前面添加如下代码 os.environ[‘FLAGS_eager_delete_tensor_gb’] = “0.0” ...
  • Solidity学习过程:storage与memory

    千次阅读 2021-08-15 14:41:02
    contract memoryTest{ uint[] arrx;//这个状态变量存储在区块链网络上 //会为arry在内存中分配空间 function test(uint[] memory arry) public returns(uint){ arrx = arry;//将内存中的arry拷贝到区块链的...
  • 有人问memory是什么意思?memory的意思很简单也不复杂,我在整理memory的相关意思和用法中,发现memory竟也能表示计算机的“记忆”,到底是什么情况?赶紧往下看!memory不仅表示“人”的记忆,更能表示计算机的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,572,273
精华内容 628,909
关键字:

memory