diff --git a/.gitignore b/.gitignore index f797a6f990ae2..06151abef9940 100644 --- a/.gitignore +++ b/.gitignore @@ -95,3 +95,5 @@ modules/ducktests/tests/certs/* modules/ducktests/tests/ignitetest.egg-info/** modules/ducktests/tests/build/** modules/ducktests/tests/dist/** +/.gigaide/gigaide.properties +*.bkp diff --git a/docs/_config.yml b/docs/_config.yml index e69a5acd3d4bf..63bbce7b55278 100644 --- a/docs/_config.yml +++ b/docs/_config.yml @@ -12,7 +12,7 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. -exclude: [guidelines.md, "Gemfile", "Gemfile.lock", README.adoc, "_docs/code-snippets", "_docs/includes", '*.sh'] +exclude: [guidelines.md, "Gemfile", "Gemfile.lock", README.adoc, "_docs/code-snippets", "_docs/includes", "elements", '*.sh'] attrs: &asciidoc_attributes version: 2.19.0-SNAPSHOT base_url: /docs diff --git a/docs/_data/toc.yaml b/docs/_data/toc.yaml index 75cb35532d972..843fee6feaf1c 100644 --- a/docs/_data/toc.yaml +++ b/docs/_data/toc.yaml @@ -127,6 +127,8 @@ items: - title: Memory Architecture url: memory-architecture + - title: Memory Budget for an Ignite Node + url: memory-configuration/memory-budget - title: Configuring Data Regions url: memory-configuration/data-regions - title: Eviction Policies @@ -137,6 +139,8 @@ items: - title: Ignite Persistence url: persistence/native-persistence + - title: Persistence Storage Budget + url: persistence/storage-budget - title: External Storage url: persistence/external-storage - title: Swapping diff --git a/docs/_docs/SQL/sql-calcite.adoc b/docs/_docs/SQL/sql-calcite.adoc index 22c54986541b0..61942fbc1bf9b 100644 --- a/docs/_docs/SQL/sql-calcite.adoc +++ b/docs/_docs/SQL/sql-calcite.adoc @@ -121,6 +121,59 @@ QUERY_ENGINE=CALCITE ---- -- +== Memory Quotas [[memory-quotas]] + +The Calcite-based SQL engine can track and limit heap memory used by query execution. +This is useful for protecting a server node from a single large query or from many concurrent memory-heavy queries. + +Two quotas can be configured in `CalciteQueryEngineConfiguration`: + +* `globalMemoryQuota` - a per-node heap memory quota for all Calcite SQL queries running on the node. +* `queryMemoryQuota` - a per-node heap memory quota for each Calcite SQL query running on the node. + +Both quotas are disabled by default (`0`). +If a quota is exceeded, the query fails with an `IgniteSQLException`. +The global quota error message contains `Global memory quota for SQL queries exceeded`, and the per-query quota error message contains `Query quota exceeded`. + +The quota is applied to query execution structures that keep rows in heap memory, for example sorting, hash joins, hash aggregates, set operations, collection operations, spools, and result materialization. +It is not a process memory limit and it does not account for Ignite data regions, direct memory, JVM native memory, or the operating system page cache. +Size these quotas together with `-Xmx` and the expected SQL concurrency. + +[tabs] +-- +tab:XML[] +[source,xml] +---- + + + + + + + + + + + + + + + +---- +tab:Java[] +[source,java] +---- +IgniteConfiguration cfg = new IgniteConfiguration().setSqlConfiguration( + new SqlConfiguration().setQueryEnginesConfiguration( + new CalciteQueryEngineConfiguration() + .setDefault(true) + .setGlobalMemoryQuota(4L * 1024 * 1024 * 1024) + .setQueryMemoryQuota(512L * 1024 * 1024) + ) +); +---- +-- + == SQL Reference === DDL diff --git a/docs/_docs/images/memory-budget-capacity-oome.svg b/docs/_docs/images/memory-budget-capacity-oome.svg new file mode 100644 index 0000000000000..5140e4709d68b --- /dev/null +++ b/docs/_docs/images/memory-budget-capacity-oome.svg @@ -0,0 +1,42 @@ + + Ignite capacity limit outcomes + A diagram showing JVM memory failure separately from page-memory pressure, where page memory can either use disk-backed page replacement or fail. + + + + + + + + + Different Capacity Limits Fail Differently + + + JVM memory limit + + heap / direct / metaspace + + + java.lang.OutOfMemoryError + large SQL results, query state, + batches, threads, code cache + + + Ignite page memory limit + + data region / checkpoint buffer + + + Alternative 1: + page replacement to disk + + + Alternative 2: + operation or node failure + + Heap-only monitoring misses Ignite page memory, direct buffers, OS page cache, and disk pressure. + diff --git a/docs/_docs/images/memory-budget-capacity-process.svg b/docs/_docs/images/memory-budget-capacity-process.svg new file mode 100644 index 0000000000000..a67a5b1403e0c --- /dev/null +++ b/docs/_docs/images/memory-budget-capacity-process.svg @@ -0,0 +1,54 @@ + + Ignite node capacity budget + A capacity diagram showing RAM budget, JVM process memory, disk budget, and the boundary between memory and disk capacity. + + + + + + + + + Ignite Node Capacity Budget + + + Host RAM + + JVM process RSS + + + Java heap + -Xmx + + Data regions + page memory + + Checkpoint + buffer + + Direct, mmap, metaspace, code cache, stacks + + + OS page cache and reserve + + Agents / sidecars + + + + Disk capacity + + WAL and archive + + Partition files + + Snapshots / logs + + + Red: memory budget + + Blue: disk budget + diff --git a/docs/_docs/images/memory-budget-data-region.svg b/docs/_docs/images/memory-budget-data-region.svg new file mode 100644 index 0000000000000..257e34f8cce67 --- /dev/null +++ b/docs/_docs/images/memory-budget-data-region.svg @@ -0,0 +1,68 @@ + + Ignite data region memory budget + A data region budget. Red shapes are page memory consumers; blue shows disk-backed page replacement when persistence is available. + + + + + + + + + + DataRegionConfiguration.maxSize + + + + Memory + Region + 1 + + Memory + Region + 2 + + Memory + Region + 3 + + Memory Segment + + + Data + pages + + B+Tree + meta + + Primary + index + + SQL + indexes + + Free lists + metadata + + Page N + + + + Checkpoint + buffer + + + If full: + page replacement + to disk or failure + + + + + Size from representative data: backups, indexes, fill factor, free lists, and partition overhead. + diff --git a/docs/_docs/images/persistence-budget-data-path.svg b/docs/_docs/images/persistence-budget-data-path.svg new file mode 100644 index 0000000000000..075bd2e9e97c2 --- /dev/null +++ b/docs/_docs/images/persistence-budget-data-path.svg @@ -0,0 +1,62 @@ + + Ignite persistence data path and storage overhead + A diagram showing how logical records become pages, indexes, partition files, backups, and overhead. + + + + + + + + + + + From logical data to persistent storage + + + Logical records + keys, values, fields + real size distribution + + + Data pages + binary rows and page headers + + Primary index + key lookup structure + + SQL indexes + indexed values and inline data + + Free lists / metadata + reuse, partitions, fill factor + + + Partition files + page memory persisted on disk + + Backups multiply data + + Snapshots copy data + + + + + + + + + + + Estimate with a representative load: object size, indexes, backups, page fill factor, and partitions all change disk usage. + diff --git a/docs/_docs/images/persistence-budget-overview.svg b/docs/_docs/images/persistence-budget-overview.svg new file mode 100644 index 0000000000000..852bbeff6df60 --- /dev/null +++ b/docs/_docs/images/persistence-budget-overview.svg @@ -0,0 +1,65 @@ + + Ignite persistence storage budget overview + A storage budget diagram showing memory, partition files, WAL, WAL archive, snapshots, operating system page cache, and logs. + + + + + + + + + + + Persistence storage budget of one Ignite node + + + + Updates + + Reads + + SQL + Workload shape + + + Data region + hot pages in RAM + + Checkpoint buffer + + OS page cache + host RAM reserve + + + Partition files + + Active WAL + + WAL archive + + Snapshots / backups + + Logs / diagnostics + + + + + + + + + + + Storage cost = data files + WAL + archives + snapshots + operational headroom + diff --git a/docs/_docs/images/persistence-budget-page-replacement.svg b/docs/_docs/images/persistence-budget-page-replacement.svg new file mode 100644 index 0000000000000..93403bd9c18fd --- /dev/null +++ b/docs/_docs/images/persistence-budget-page-replacement.svg @@ -0,0 +1,63 @@ + + Ignite page replacement and persistence I/O + A diagram showing hot pages in memory, cold pages on disk, page reads, clean eviction, dirty page checkpoints, and WAL writes. + + + + + + + + + + + Page replacement turns memory shortage into disk I/O + + + Data region in RAM + + hot + + hot + + dirty + + index + + free + + evict + candidate + + + Partition files + cold pages and checkpointed pages + + Active WAL + + Checkpoint writes + + + A small data region can save RAM, but page misses, checkpoints, and WAL writes must fit disk latency and IOPS. + + + + + + + + page miss read + clean eviction + update WAL + dirty page checkpoint + diff --git a/docs/_docs/memory-architecture.adoc b/docs/_docs/memory-architecture.adoc index 4f8fe42d7c122..fcc168c0db132 100644 --- a/docs/_docs/memory-architecture.adoc +++ b/docs/_docs/memory-architecture.adoc @@ -29,6 +29,8 @@ Multi-tiered architecture is a page-based memory architecture that is split into Ignite maintains the same binary data representation both in memory and on disk. This removes the need for costly serialization when moving data between memory and disk. +For production sizing, see link:memory-configuration/memory-budget[Memory Budget for an Ignite Node]. + The picture below illustrates the architecture of the multi-tiered storage. image::images/durable-memory-diagram.png[height=700px] diff --git a/docs/_docs/memory-configuration/memory-budget.adoc b/docs/_docs/memory-configuration/memory-budget.adoc new file mode 100644 index 0000000000000..b4f561e489cab --- /dev/null +++ b/docs/_docs/memory-configuration/memory-budget.adoc @@ -0,0 +1,181 @@ +// Licensed to the Apache Software Foundation (ASF) under one or more +// contributor license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright ownership. +// The ASF licenses this file to You under the Apache License, Version 2.0 +// (the "License"); you may not use this file except in compliance with +// the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. += Memory Budget for an Ignite Node + +This page describes the full memory budget of a production Ignite server node. +Ignite stores cache data and indexes in off-heap page memory, but the Java heap, JVM native memory, direct buffers, operating system page cache, and other processes on the host are still part of the sizing exercise. + +image::images/memory-budget-capacity-process.svg[Ignite memory and disk capacity budget] + +[IMPORTANT] +==== +`-Xmx` is only the maximum Java heap size. +It is not the maximum size of the JVM process and it is not the maximum RAM used by an Ignite host. +The process resident set can be much larger than `-Xmx` because it also includes off-heap data regions, direct or memory-mapped buffers, metaspace, code cache, thread stacks, JIT and JVM native structures, and native libraries. +==== + +== Where Memory Goes + +[cols="1,3",opts="header"] +|=== +| Memory area | What it contains + +| Java heap +| Objects created by Ignite and by application code running in the node: SQL result pages and reducer-side results, transaction state, cache operation batches, compute and service objects, discovery and communication metadata, near caches, on-heap caches, SQL on-heap row cache, continuous query state, distributed data structures, management tasks, metrics objects, and temporary objects created during serialization and deserialization. The Calcite-based SQL engine can additionally enforce link:SQL/sql-calcite#memory-quotas[per-query and global heap memory quotas]. + +| Ignite data regions +| Off-heap page memory configured with link:memory-configuration/data-regions[data regions]. This is where cache entries, primary key indexes, SQL indexes, partition metadata, free lists, reuse lists, and other page-based structures reside. The default data region can grow to 20% of available physical memory unless configured explicitly. The system data region also uses off-heap memory for internal caches and metadata. + +| Direct memory +| Java NIO direct buffers and memory-mapped buffers used by communication, thin clients, REST, SSL, WAL writing and reading, page store I/O, snapshots, defragmentation, performance statistics, and other I/O paths. With persistence, the WAL path can use memory-mapped files by default, or direct buffers when memory mapping is disabled. + +| JVM native memory +| JVM memory outside the heap, such as metaspace, compressed class space, code cache, thread stacks, garbage collector structures, JIT compiler memory, JNI allocations, and memory used by loaded native libraries. Thread count and loaded classes directly affect this area. + +| Checkpoint buffers +| Temporary off-heap page buffers used when persistence is enabled. They hold copies of pages that are being written to disk while the same pages are updated concurrently. The buffer is configured per data region with `DataRegionConfiguration.checkpointPageBufferSize`; when unset, Ignite calculates it from the data region size. + +| OS page cache +| Host RAM used by the operating system to cache partition files, WAL files, WAL archive files, indexes on disk, snapshots, logs, and other files. With link:persistence/native-persistence[native persistence], this cache is important for stable disk throughput and checkpoint behavior. + +| Other host processes +| Monitoring agents, log collectors, backup tools, security agents or scanners, antivirus, sidecars, direct I/O helpers, shell sessions, and orchestration daemons. Their peak memory usage must be reserved outside the Ignite JVM budget. +|=== + +== Capacity Planning + +Plan memory before tuning persistence storage. +This page focuses on memory inside and around an Ignite server node: Java heap, off-heap page memory, direct and native memory, OS page cache reserve, and other host processes. +For WAL, partition files, snapshots, page replacement, and disk/IOPS sizing, see link:persistence/storage-budget[Persistence Storage Budget]. + +For a new deployment, prefer measurement over guessing. +Start a test node with production-like cache, data region, persistence, SQL, and JVM settings; load a representative data sample; run the expected read, write, SQL, rebalance, and maintenance operations; then record heap, process RSS, data region metrics, checkpoint buffer usage, direct/native memory, OS page cache pressure, and other host processes. +Use analytical estimates only as an initial budget or as a cross-check for measured results. + +== Why Heap Is Still Needed + +Data and indexes are stored off-heap, but operations still create heap objects. +When a query reads off-heap rows, Ignite may copy or deserialize data into heap objects before returning it to the caller. +Distributed SQL queries also keep result pages, reducer-side intermediate data, sorting and grouping state, and query metadata on heap. +Large `SELECT` results, joins, `GROUP BY`, `ORDER BY`, DML, `ScanQuery`, `getAll`, `putAll`, `invokeAll`, data loading, rebalancing, transactions, compute jobs, services, and application listeners can all create heap pressure. + +Heap usage is workload-dependent. +A node with a small amount of stored data can still exhaust heap if it runs many large queries, colocated computations, services, continuous queries, or large cache operations. +Conversely, a node can have low heap usage and still hit page-memory pressure if a data region or checkpoint buffer cannot allocate another page. + +== Data Region Budget + +For each server node, size every data region explicitly: + +image::images/memory-budget-data-region.svg[Ignite data region memory consumers] + +* Include primary and backup entries owned by the node. +* Include binary object overhead, per-entry metadata, page headers, partially filled pages, partition metadata, free lists, reuse lists, primary key indexes, and SQL indexes. +* Include index inline size and the number of indexed fields. A fixed percentage for indexes is often inaccurate because index size depends on the indexed values and inline configuration. +* Include the system data region and any special regions used by the deployment. +* Decide whether the region is persistent or in-memory only. + +For a new workload, load a representative data sample and monitor data region metrics such as `PhysicalMemorySize`, `TotalAllocatedSize`, `TotalUsedPages`, and `PagesFillFactor`. +Then extrapolate from real data rather than from source file size. +Make sure the sample represents key and value sizes, string lengths, indexed fields, partition distribution, backups, and update patterns. + +== Host Sizing Checklist + +Use this checklist per physical host or container: + +* Total RAM available to the node after container or cgroup limits. +* Sum of all Ignite data region `maxSize` values, including the default and system regions. +* Java heap size, with enough headroom for SQL result sets, transactions, cache batches, compute/services, application code, near/on-heap caches, operational tasks, and any link:SQL/sql-calcite#memory-quotas[Calcite SQL memory quotas]. +* Direct memory for WAL, communication, clients, SSL, page-store I/O, snapshots, defragmentation, page lock tracking, and performance statistics. +* JVM native memory: metaspace, code cache, thread stacks, JIT, GC, JNI, and native libraries. +* OS page cache reserve, especially when native persistence is enabled. +* Monitoring, security, backup, logging, and sidecar overhead. +* Emergency reserve for spikes, rolling upgrades, topology changes, rebalancing, index rebuilds, failover, and incident diagnostics such as heap dumps or Flight Recorder. + +A practical budget is: + +[source,text] +---- +Host RAM >= + Java heap + + sum(data region maxSize) + + checkpoint buffers + + direct and mmap buffers + + JVM native memory + + OS page cache reserve + + other host processes + + emergency reserve +---- + +For in-memory deployments, the memory tuning guide recommends not allocating more than 90% of host RAM to Ignite nodes. +For persistent deployments, leave additional RAM for the OS page cache and review link:persistence/storage-budget[Persistence Storage Budget]. +Treat these values as starting points and validate them with production-like load, checkpoints, rebalancing, failover, and monitoring agents enabled. + +== Monitoring + +Monitor both JVM memory and Ignite data region memory. +Heap-only monitoring is not enough. + +Watch at least: + +* Process RSS or container memory usage from the operating system. +* Java heap and non-heap metrics. +* Data region metrics: `PhysicalMemorySize`, `TotalAllocatedSize`, `TotalUsedPages`, `PagesFillFactor`, `OffHeapSize`, `OffheapUsedSize`, `UsedCheckpointBufferSize`, and eviction or replacement rates. +* For persistent nodes: checkpoint, WAL, archive, and disk metrics described in link:persistence/storage-budget[Persistence Storage Budget]. +* SQL query concurrency, result page size, slow queries, and large result sets. +* GC logs, heap dumps, and JVM native memory if native memory tracking is enabled. + +== Understanding Out-of-Memory Errors + +image::images/memory-budget-capacity-oome.svg[Ignite memory capacity failure modes] + +`OutOfMemoryError` usually means the JVM could not allocate Java heap, direct buffer memory, metaspace, or another JVM-managed/native area. +Examples include large SQL results, unlimited on-heap row cache, large cache operation batches, too many concurrent transactions, many threads, or too small `-XX:MaxDirectMemorySize`. + +`IgniteOutOfMemoryException` usually means Ignite page memory could not allocate a required page or checkpoint copy. +Examples include an undersized data region, disabled or insufficient eviction for in-memory regions, a checkpoint buffer that is too small for a write-intensive persistent workload, or per-partition/index/free-list overhead that was not included in sizing. + +The remediation is different: increase or tune heap/direct/native JVM memory for `OutOfMemoryError`, and resize data regions, checkpoint buffers, page replacement/eviction settings, or the data model for `IgniteOutOfMemoryException`. + +== Common Mistakes + +* Allocating all RAM to Ignite and leaving no room for JVM native memory, OS page cache, monitoring agents, security tools, or emergency reserve. +* Treating `-Xmx` as the total JVM process limit. +* Ignoring OS page cache with native persistence enabled. +* Relying only on Java heap usage for memory monitoring. +* Enabling large SQL queries, high query concurrency, or SQL on-heap row cache without considering heap pressure. +* Enabling the Calcite SQL engine without deciding whether link:SQL/sql-calcite#memory-quotas[query memory quotas] should protect the node from large sorts, joins, aggregates, and result materialization. +* Sizing data regions from raw file size and ignoring binary format overhead, page fill factor, primary and SQL indexes, free lists, partition metadata, and backups. +* Forgetting checkpoint buffers and WAL/direct memory when persistence is enabled. +* Running multiple Ignite nodes on the same host or disk without dividing RAM, page cache, WAL throughput, and I/O capacity between them. +* Forgetting memory used by snapshots, defragmentation, CDC, performance statistics, backups, idle verify, page lock tracking, platform caches, and index rebuilds. + +== Related Topics + +* link:memory-architecture[Memory Architecture] +* link:memory-configuration/data-regions[Configuring Data Regions] +* link:memory-configuration/eviction-policies[Eviction Policies] +* link:memory-configuration/replacement-policies[Replacement Policies] +* link:persistence/native-persistence[Ignite Persistence] +* link:persistence/storage-budget[Persistence Storage Budget] +* link:persistence/persistence-tuning[Tuning Persistence] +* link:SQL/sql-tuning[SQL Tuning] +* link:SQL/sql-calcite#memory-quotas[Calcite SQL Memory Quotas] +* link:configuring-caches/on-heap-caching[On-Heap Caching] +* link:configuring-caches/near-cache[Near Caches] +* link:monitoring-metrics/new-metrics-system[Monitoring Metrics] +* link:perf-and-troubleshooting/memory-tuning[Memory and JVM Tuning] +* link:perf-and-troubleshooting/troubleshooting#debugging-gc-issues[Debugging GC Issues] +* link:perf-and-troubleshooting/handling-exceptions[Handling Exceptions] diff --git a/docs/_docs/persistence/native-persistence.adoc b/docs/_docs/persistence/native-persistence.adoc index 18f8f677cd8e5..5e7dd97b1ba44 100644 --- a/docs/_docs/persistence/native-persistence.adoc +++ b/docs/_docs/persistence/native-persistence.adoc @@ -164,6 +164,13 @@ The purpose of the write-ahead log is to provide a recovery mechanism for scenar The WAL consists of several files (called active segments) and an archive. The active segments are filled out sequentially and are overwritten in a cyclical order. Once the 1st segment is full, its content is copied to the WAL archive (see the <> section below). While the 1st segment is being copied, the 2nd segment is treated as an active WAL file and accepts all the updates coming from the application side. By default, there are 10 active segments. +[WARNING] +==== +Do not change the number of active WAL segments (`DataStorageConfiguration.walSegments`) for an existing persistent work directory. +Active WAL segment files are reused cyclically according to this value, so changing it after the node has already created its persistence storage can make the node look for different active WAL files during recovery or checkpoint processing. +If you need a different number of active WAL segments, configure it before the persistent storage is created, or start the node with a clean work directory after taking the required backups. +==== + //////////////////////////////////////////////////////////////////////////////// *TODO - Do we need this here? I think not. Move to the javadoc. (Garrett agrees, let's move this out)* @@ -364,6 +371,7 @@ The following table describes some properties of link:{javadoc_base_url}/org/apa | `walPath` | The path to the directory where active WAL segments are stored. | `${IGNITE_HOME}/work/db/wal/` | `walArchivePath` | The path to the WAL archive. | `${IGNITE_HOME}/work/db/wal/archive/` | `walCompactionEnabled` | Set to `true` to enable <>. | `false` +| `walSegments` | The number of active WAL segments. Configure this value before creating persistent storage. Do not change it for an existing persistent work directory. | `10` | `walSegmentSize` | The size of a WAL segment file in bytes. | 64MB |`walMode` | <>. | `LOG_ONLY` diff --git a/docs/_docs/persistence/storage-budget.adoc b/docs/_docs/persistence/storage-budget.adoc new file mode 100644 index 0000000000000..6b50b4d79eb6b --- /dev/null +++ b/docs/_docs/persistence/storage-budget.adoc @@ -0,0 +1,185 @@ +// Licensed to the Apache Software Foundation (ASF) under one or more +// contributor license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright ownership. +// The ASF licenses this file to You under the Apache License, Version 2.0 +// (the "License"); you may not use this file except in compliance with +// the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. += Persistence Storage Budget + +This page helps plan the storage and I/O budget of an Ignite node with link:persistence/native-persistence[native persistence] enabled. +If your goal is to reduce persistence cost, first identify which files and I/O paths consume capacity: partition files, WAL, WAL archive, snapshots, logs, and the OS page cache. +For JVM heap, off-heap data regions, direct memory, and host RAM sizing, see link:memory-configuration/memory-budget[Memory Budget for an Ignite Node]. + +image::images/persistence-budget-overview.svg[Ignite persistence storage budget] + +== What Uses Disk Space + +[cols="1,3",opts="header"] +|=== +| Area | What to budget + +| Partition files +| Persistent data pages, primary-key indexes, SQL indexes, free-list and reuse-list pages, partition metadata, page headers, and partially filled pages. Their size depends on binary object size, key size, backups, indexes, fill factor, and the number of partitions. + +| WAL active segments +| The current write-ahead log files in `walPath`. They are reused cyclically. By default, Ignite creates 10 active WAL segments of 64 MB each. + +| WAL archive +| Archived WAL segments needed for recovery, rebalance, CDC, snapshots, and operational safety. Reducing the archive too aggressively can increase operational risk. + +| Snapshots and backups +| Full snapshots can require storage comparable to the persistent data set. Incremental snapshots and CDC also retain WAL-derived data. + +| OS page cache +| Host RAM used by the operating system to cache partition files, WAL, WAL archive, snapshots, and logs. It is not disk space, but it is part of the persistence cost model because too little page cache turns into more physical reads. + +| Logs and diagnostics +| Application logs, GC logs, heap dumps, WAL dumps, index rebuild artifacts, defragmentation work files, and other incident files. +|=== + +== How to Choose a Size + +Use one of two sizing methods, or combine them. + +The most reliable method is to build a test node with production-like configuration and load a representative data sample. +The sample does not need to contain the full production data set, but it must preserve the real shape of the data: key size, value size, string lengths, indexed fields, backups, partition distribution, update rate, and query mix. +After loading the sample, measure the actual footprints and extrapolate: + +* Partition file size under `storagePath`. +* WAL active size under `walPath`: at least `walSegments * walSegmentSize`. +* WAL archive growth under `walArchivePath` during load, updates, rebalancing, and snapshots. +* Snapshot and backup size for the same sample. +* Data region metrics such as `TotalAllocatedSize`, `TotalUsedPages`, and `PagesFillFactor`. +* Checkpoint duration, dirty pages, page write duration, throttling time, and page replacement rate under realistic write load. +* Operating system disk metrics: queue depth, read/write IOPS, throughput, and p95/p99 latency. + +Then scale the measured values by the expected production record count and add headroom for growth, rebalancing, topology changes, snapshots, maintenance, and incident files. +Do not extrapolate from the source CSV, JSON, or database export size alone; Ignite stores binary rows, indexes, page metadata, and partially filled pages. + +The analytical method is useful before hardware is available or to cross-check a measured result. +Start with: + +[source,text] +---- +Persistent data size ~= + data pages + + primary indexes + + SQL indexes + + partition metadata, free lists, and page overhead + + backup copies + +Required disk >= + persistent data size + + active WAL + + WAL archive retention + + snapshots and backups + + logs and diagnostics + + emergency free space +---- + +Analytical sizing is only an estimate. +Validate it with a test node before reducing disks, WAL archive retention, or the RAM reserved for the OS page cache. + +== Estimate From Data, Not Source Files + +Raw source-file size is not a reliable predictor of persistence size. +Ignite stores data in a binary format, splits storage into pages, and builds indexes and internal metadata. +The same logical data set can have very different storage size depending on string lengths, binary object layout, backups, indexed fields, inline size, fill factor, and partition distribution. + +image::images/persistence-budget-data-path.svg[Ignite storage overhead from object to pages] + +For a new workload, load a representative data sample and measure: + +* Partition file growth. +* WAL and WAL archive growth during the load. +* Data region metrics such as `TotalAllocatedSize`, `TotalUsedPages`, and `PagesFillFactor`. +* Index size impact after adding SQL indexes. +* Backup factor and partition distribution. + +Use samples that preserve real distributions. +If string lengths, nested objects, indexed values, or partition affinity are skewed in production, the sample must preserve that skew. +The more variable the object sizes are, the larger the sample should be before extrapolating. + +== Memory-to-Disk Ratio + +With persistence enabled, data can be larger than the off-heap memory allocated to data regions. +When a required page is not in memory, Ignite reads it from partition files; when memory is full, page replacement chooses another page to evict. +Evicting a clean page is cheap, but reading it back is expensive and depends heavily on disk latency and IOPS. + +image::images/persistence-budget-page-replacement.svg[Ignite page replacement and disk IOPS] + +When choosing how much RAM to buy versus how much disk to buy, consider: + +* The hot data set that must stay in memory to meet latency targets. +* The cold data set that can live mostly on disk. +* The number of random reads caused by cache gets, SQL indexes, scans, and rebalancing. +* Disk IOPS and latency percentiles, not only throughput in MB/s. +* Whether full scans or rare indexes can evict useful hot pages. +* Whether hot and cold caches should use separate data regions. + +Do not size this only by average latency. +Page replacement usually shows up in tail latency first: the median may look fine while p95 or p99 is dominated by disk reads. + +== WAL, Checkpoints, and Archive + +Every update is written to the WAL before it is considered durable. +Later, checkpointing writes dirty pages from memory to partition files. +The WAL path, WAL archive path, and partition files can therefore compete for the same disk if they share a device. + +Budget for: + +* Active WAL segments: `walSegments * walSegmentSize`. +* WAL archive size and retention needs for recovery, rebalance, CDC, and snapshots. +* Checkpoint write throughput to partition files. +* Temporary checkpoint buffer pressure in memory; see link:persistence/persistence-tuning#adjusting-checkpointing-buffer-size[Adjusting Checkpointing Buffer Size]. +* Snapshot, defragmentation, index rebuild, and backup temporary files. + +[WARNING] +==== +Configure `DataStorageConfiguration.walSegments` before the persistent work directory is created. +Do not change the number of active WAL segments for an existing persistent work directory. +Active WAL segment files are reused cyclically according to this value, and changing it later can make recovery or checkpoint processing look for different active WAL files. +==== + +== Cost-Saving Checklist + +Use this checklist before reducing persistence cost: + +* Reduce unnecessary SQL indexes; index size depends on indexed values and inline size. +* Keep only required backups. +* Separate hot and cold data into different data regions where possible. +* Keep enough RAM for the hot set and OS page cache; starving RAM can move cost from memory to disk latency. +* Put WAL and partition files on separate physical devices for write-heavy workloads. +* Avoid running multiple persistent Ignite nodes on the same physical disk unless IOPS are divided and validated. +* Set WAL archive size based on recovery, rebalance, CDC, and snapshot requirements, not only on minimum disk usage. +* Store snapshots on separate media when possible. +* Use disk compression only after testing CPU cost and latency. +* Validate with production-like load and monitor p95/p99 latency, checkpoint duration, WAL archive growth, and disk queue depth. + +== Monitoring + +Monitor: + +* Disk free space for storage, WAL, WAL archive, snapshots, and logs. +* WAL archive segment count and archive growth rate. +* Checkpoint duration, page write duration, dirty pages, and throttling time. +* Page replacement and cache miss rates. +* OS page cache pressure, disk queue depth, IOPS, and read/write latency percentiles. +* Snapshot, CDC, defragmentation, and index rebuild activity. + +== Related Topics + +* link:persistence/native-persistence[Ignite Persistence] +* link:persistence/persistence-tuning[Tuning Persistence] +* link:persistence/snapshot-directory[Configuring Snapshot Directory] +* link:persistence/disk-compression[Disk Compression] +* link:memory-configuration/replacement-policies[Replacement Policies] +* link:memory-configuration/memory-budget[Memory Budget for an Ignite Node] diff --git a/docs/elements/Ignite_troubleshooting_talk.drawio b/docs/elements/Ignite_troubleshooting_talk.drawio new file mode 100644 index 0000000000000..c938239f96452 --- /dev/null +++ b/docs/elements/Ignite_troubleshooting_talk.drawio @@ -0,0 +1 @@ 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7V1dk6I4FP01Pq5FvsPjtj3T+zBbu1X9sN2PEaNSjeJibHV//QYJKOiMOtMwCZm2qotcIOmcczlc+ubiAI0Wu6dMrOZ/phOZDGAw2Q3Q4wBCBqj+nRv2hQFjXhhmWTwpTOBoeI7/k8YYGOsmnsh17UCVpomKV3VjlC6XMlI1m8iydFs/bJom9VFXYibPDM+RSM6t/8QTNS+sHLKj/Q8Zz+blyICGxZ6xiN5mWbpZmvEGEE0PP8XuhSj7MhNdz8Uk3Z6Y0KcBGmVpqoqtxW4kkxzaErb5VL6J6DNUcPEqnl7/HcEv+99MZwP4+Z6zqklmcqk+vPcQF6e9i2QjSzAOU1b7EubtPFbyeSWivL3VnjRAD3O1SHQL6E2xXhXkTuOd1GM9JGIsk4cK4lGapNmhpxJk9LBWWfomT/bwQIiI6z3TdKmezdi3Tt0c9y4zJXcnrmFweJLpQqpsrw8xexExaJWOb5rboxcBbmzzUw8qjcJ47qzquoa93jDw30MFsoyKttAnQR19SKyAH3oCP7QS/vKPsEeI4iS5dEZbtICwQYsVooTIdVp0N/qOrxsPvSaoigZKgtgFguAlgmCLBAFwnaAc3ZwKHYcpES9ljljw40hVgZ0YlyMF30YQ1BFE4BxBfAFA3KaDs1vx6xqswEKwbogWD1dyfnUfXOyKInRxg6wYvn6l/0RowQ3Rn34MWeWb0T6JNcYZug7wuGDjy7gyVGD/tVG6G2ns6+Lpjg4hgwwREhIWIADJPRIs+RRORSvMlI+sQ1K7KMjZJVGaTnkrba3whq3gjQwR1R+tGhBgjhHrBXGgReIQt1X46fX4vHPhD10Ufu6C8OPAQ+Hn7gs/Bj4KP3df+DG0VPgRtC/ix8hB4a8Ytlv4sX/Cfwcz9go/8VD4uyKuVeGnjkT8iFkg/MxF4adOCD/3UPhpD4Q/9FH4qfvCT6DnuUVsZW6RoF+5xXJJhJW5RYLdyS0SC3OLhFgacBILc4uEOhhwVgxbHXAS5l/AeQcz1gachHsYcHZFXKsBZ2ir8FuYW6SBi8IfuiD8FHgo/KH7wk+hj8Ifui/8FFkq/NTC3CJ1cTVhxbDdwk/8E/47mLFX+KmHwt8Vca0KP3Mk4rcht0i5i8LvxDJyGnoo/D1YRs4CH4W/B8vIGfA8t4hw4wZjQ2qRwV+pxV3jhm/4oTZkFhlyJ7OIGhEUCH5+BMWwrWuYiYVgEQfDzYphq8NNRv0LN+9gxt5wk3kYbnZFXKvhpq1VixhcfaVO5+LkYtEic6JokXtYtMh6ULTIfSxaZD0oWuS2Fi1iZl/Az10sWuROFC1yD4sWeQ+KFrmPRYu8B0WLnDoS8ANqgfC7WLTInSha5B4WLfIeFC1yH4sWeQ+KFsM7HtWmidz9nr9QW0MklxOz+RglYr2OowPSIlPn5hNC67L4tSTVGWME5J/DsHreL6azQ+M172tIyubjzvRdtPbflc1Zp5sskjeUeur5zqS64X2zclJ7x/g3Nbd6tqn5QGnMZCJU/F5/N/klzzBj/J3GesrH+ylq/AOtmX8r5m7Oarzqu9FXM+eHmn0V8Fzq6+Cr1fR/oATCMffdxerl6LC69Vq6q94++m7e2J868stpo3B51rXPBzf6fLlWwRqfh/grdcnf4/PNzGP3Ph8Gvff5luTaGo8kPBgGJz/gw/yzWeIN2Af6p24ev42iOPz4jR/o0/8=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7Zddc6IwFIZ/DZfuQHAVL4u224vu19iZndmbToAjZBsIG2LF/fV7IgmK1tbOWO2F3JC85yPJyZMwOP44r79IWmZfRQLcIW5SO/7EIcQjowBfWlk2SuC5jZBKlhintTBl/8CI1m3OEqg6jkoIrljZFWNRFBCrjkalFIuu20zw7qglTWFHmMaU76q/WKIyswoyXOu3wNLMjuwNRo0lovFjKsW8MOM5xJ+tnsacU5vLLLTKaCIWG5J/7fhjKYRqWnk9Bq5ra8v2E+6//bkPg176UIF4mP4OpuOeSeaQm7dEtYuUUKjjZ//chD1RPjdVvZ1MepJiFLkpnnIwFVBLW3UsRqmb8ZKzIgHpO364yJiCaUljbVggbahlKufY87AZ6VJDche1QrsB3+cK04DRq4YxnJUfchoBD1vHseBCoq0Q2juslBSPYEXcQNcdunFs436IiikmCj1PrBugU/gEUjGk527LIRJKiRwdKGfpsxFXxqCEXthMFMocBo/oPuN8YyIQzMiMGr/OBPWDuqk45oZ6C+RX9thr2cMzDSIHJZcYZ7MMDAPmONvuYn02SN9oWedcGJGa85i2qTtEYcNA9RbABjuAOWTAcegwxgupg9bg71yfqJCDwvr3KuSJFanjX6GXW9ar0rm6qr2GE617xBhsMLZS/dZs1p8iVtjhcPrNiI19h2vZQIod93Wi9+35fixX1JjR3Bfo2KbrVLR4/oG4kPekZXgmWrCYquddcDkYl9EuLS1BJ6MlOCct/Q9OS+cTdeJPUYvHC7R4p6ZldDxaiLsfmD13i3+5XA7/Fnkf4Haxuc/DS/9yvRx+vTzLy/HuF+yu//VWto0fav/6Pw==7Vlbc6IwGP01PNYBQrg8Vu223eltxuns1rcIUTONxA2x6v76DRIuEW21UyyzIy/NdxK+NN85ORA0QG+2uuZoPr1nEaaGbUYrA/QN27ZM4Ms/KbLOENdRwISTSA0qgQH5i/M7FbogEU60gYIxKshcB0MWxzgUGoY4Z0t92JhRfdY5muAaMAgRraO/SCSmGerbXonfYDKZ5jNbbpD1jFD4OuFsEav5DBuMN1fWPUN5LrXQZIoitqxA4MoAPc6YyFqzVQ/TtLZ52e5/8ufLh+V8evt4PwyGQ+7aVxcqmWH/OOauYpEcx+LLs4PsrjdEF6qoA8zfMJfYg9SLWr5Y5yXfFA2nGU0DdJdTIvBgjsK0dylFJrGpmFEZWbI5JpT2GGV8c29eYtBNBGevuNLjmwiFfnoHi0UFNzeXxA+sgaqV/P8FXlU0ogpyjdkMC76WQ1Sv46uyqR3gqXBZyskCCptWpOQqDCkFT4rMGgeyoWg4ghJYo6TGAo6jy3T/yCikKElIqBdeZwmviPidtjuu66v4ZRMH0FZxf1UZ3F9XgifMiVwb5jkWy3Vm6WAevlT7ylSbaF2NtpMdx6tAfILfG6c2Po4036izX6EX7mA3xzimSJA33W12Ua5meGJELqMQF3TNjulo+rLsoAOtoLx8PWnCFjzEKs/Wdt7KDixdunBLklmxdqXaqLKoxueF6tWEetPv17QqvXOeNsM1JVKUHHzsG6NMvnejAij8+nEhZBqs8CR7JFmpECkaYdotBuYuErN0dN1yTNMzw7BuUtgf22P0DVYETZ3PwmOqXmTvUKvXoBf5Zy/aQ2xbPMbb6TFB9fI+7THQq2my4/in9pngLMKWi9Bv8kEH/T3GeDoF5o/aswRbK8GgUR8M2uCDlnVWYctVCBtVIWyFCu2zCtutQtdsUoWueWIVBlbMvWf6h7j4dtQlQ4C6dxeHPJApJfNkc/jLj6CULaKPj597TpIHfsHa882rqWMjcLfogAceG/2vOTbuZKf+oHrAYsn4a40kuUqhV18vrTq+V6uqIETJJE5JlQVN92s3rRkJEb1UHTMSRek0O+nWHej9bweNUbf9VuHBGnXuDuZAg8x9vbmXduzauiF37NN+MnzPSFpi3U7gdhwHej6wgA2Baekuvs38MS8P2z7hfYdtg/9MXm1577SshmTj1N453VNrxjlrphHN2I1pxm1QMzIsf3fNhpc/boOrfw==3VjLbuIwFP2aLJESO0BYlrQDw4D6QJqqq8okN4lLEkfG4bXot49NHEiUVnQkmhmRDdfn+nmOfX2Ngd1kO+Iki2bMh9hApr818K2BkGVjR/4oZKcR0x4USMipr7ETMKd7KCtqNKc+rGoVBWOxoFkd9FiagidqGOGcberVAhbXR81IqEc0T8DcIzE0qj1TX0QF6qD+CR8DDaNyZKun17cg3jLkLE/1eAbCweEr3Akp+9LjriLis00FwncGdjljorCSrQuxIrekTbcz0I9PKhynziEVX2zzkJiv+2X0OJl0M8t6fDUXU9bRHa1JnGtWJmRNxkAyA7nS8Y6tkV6E2JXEHZYOqlvTwMNNRAXMM+Ip70buFYlFIollyZJmQOPYZTHjh7Y4AAgC1WwlOFtCxeMBMrGtWrBUVHDz8Em8ueZy9sAFbCuQJmAELAHBd7KK9iJH06T3bF8XNyf9rRKLKtr3NEb0lguPPdc4l4am/S8kQA0JbiSZEUjsZ5hKbqXxBCFlqYF6sZzQcMGlFSrrvdt3RosrEqjTPysQMlsWqNsQyI3AW2aMymXKaJAHAXB1Vq5LCss+K0XbR6XfUKLBt4y1mTLl0gUl8ZO8OEgaKu858gXLtEoLJgRLdKGqScpS+J593sFNdnvOB/Sib6TXuT56K3Ri3PJuHVwNncdrs3pPDlqms0wbK3zez9VYMg1DJhORCsKXjL5FSncRAu3zeUevbTqbqd/zzbSZYsjrTd1t1lXdbccw+rkedtt62A09pjTNtxJ6UA8ZZLpFVng1InT/aYLxaza0vH0HBuOXaf57dvuWvM0/eA6N3OaRuF//v4Gm+4X8+VKcyuLpEXvwVf4qwHd/AA==7Z3dc5s4EMD/Gs/cPTgDCH892k7itpe2mfoh00cZBCgRiIL8kf71J4GwwdD60quRpqM8JHglJNjf7rK7IZMBWMaHVQbT6CP1ERk4ln8YgNuB49gumPIfQvJaSsburBSEGfblpJNgjb8jKbSkdIt9lDcmMkoJw2lT6NEkQR5ryGCW0X1zWkBJc9cUhnJH6yRYe5Cg1rQn7LOolE6dyUn+DuEwqna2x/L+NtB7CTO6TeR+AwcExVc5HMNqLblvHkGf7msicDcAy4xSVh7FhyUiQreV2sjhEfnu5MN0m3/9B7FPz+Hn7VAuNnDu33LW8SYzlLDfvrpTnrWDZCuV+gHu4DsEUy4F9kreP3utdF5oDYklrQFY7CPM0DqFnhjdcyvjsojFhH+y+WHOMvqClpTQrDgbeIiv6vKRgCasJreKLyHHhNTkAUJBIOT/UQlSWTuUMXSoGYnUyArRGLHslU+Ro85U6k26wER+3J/sya5kUc2WxlIGpQmHx5UbEPiB5PAGJqDFZM41HCEuex8mXOH84AsKMU0GzpjwC1psMn4UsqOefpUXgRtEHmmOmVgc3Hpc24ijWAiFYu54D2cTGBUrQILDzulzObChjNH4J3jfbijXMojhZYM4xr++DMJtGcQyQt5LSjG/dx7NtkHA1d4v+Rj7vtjpMvzjzLdDLq5qcQzW1ZSEJkhBrLDdi6bRd6iYtSzjaf7QjgrcQv74QO5chOP2DKcKEzU6FZo8hUkDx/jbViQTC69U2ZwPZuHmL6u4CL69VTv6WxwKTVpC+cMAxpi8luecFooQ2SHhhydR87S8SOfESbaTHs7GyusSgwnNYkiaw3upQDHulldWDBLEeAgY8pvzcBJ2ns9psqEMGWJYRo3GMOZ2mcjlrdqlFYMsg0ke8EWr5RN0nLCnmd/cvX76KekbnmnZGY2O2j07rumaUMg6NvVxnhIo9Y8TgsXYSeXVY7n9oC4l3LJKY/jB81vc9GX/vJZXAdD0Kht05EfjDr8aXdOv7JZfPeBkK0g/iorBsZZluvRnR7yRfo8ju11OfN79Zg5TC0Jv2uZwktc4yEzhWgjc0eVksW8E4CcVnda1gSkWf4X3tO1xa7FV4vPvlEX/tzDQ2/9mF4GMrsdj/B2M4nkQDa27T2zlPsP398OOWq2l/x85zNETzl2k9KQ6lAimYrH4EIrO3s0G5ti7SaFIv5J7rv8vRbutQLGWG/sYhgVPxBe7HR1HBd6qe2bdOA153bnK/liHQSB3AsaeAnc8L9Vtp40fdOC3r4h/ZPD3hn+kH/6xwa8Mv60e/8TgVxb8NcA/Nfh7w+/oF/xnBn9vrXj96Hd2ew3+XvBrEPs7mpIGf1/BXwf+pvBXxn+mAX5T+KuK/jrQN3W/ssJPB/ym7lfW9tEAv2Myf2WZv6UBfmDwK2v66sDfZP7qur468Depv7rKXwP+wHR+lPn/VAP8jsGvCv9EA/zm6a8s+9PB+83DXxl+HbzfNP6U5X464DeNP2X4dQj+5oUfVY0/Heib931U0e839D+OZ3lIwbftahNQ+PD89DFfDE3V1xt8V+nLXp30TctfGX1bPX1T8quiP1MP3xT8ylzfUk/f1Puq6E/VwzfVvir4GiT8ptbvDf5Ev4Tf1PrK6GuQ8Ju/7VGGX4OM3/xpjzrn1yDlt02rTxV+DXJ+27T6VNHXoctvSr4ef8ejX9rvmKpPHX8NEn/H1H3K+GuQ+QNT96lzfw1Sf/Nqvzr+GuT+5tV+dfivmvzzj6d/3lKM1f5DDrj7Fw==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7Zpdd6o4FIZ/jZe6kvAhvWzV6uk4czp1ZrUzN10RA2REwmCstr/+BAjIl5X2VGTNqBfCTkgg75Nk740dZbDajQPsO7+yBXE7CCx2HWXYQQiqiiF+QsurtAD1KrbYAV1I294wo28kqSitG7og61xFzpjLqZ83mszziMlzNhwEbJuvZjE336uPbdkj2BtmJnZJqdojXXAnthqov7dPCLWdpGeoy+ebY3NpB2zjyf46SLGiT1y8wklbst+1gxdsmzEpo44yCBjj8dFqNyBuOLjJsL1ZXWU8eP5LfxiZXv8f8uTdbLuysQ66/chV6UMGxONf3roSX/WC3Y0c1Dv8gicE+/LJ+Wsy2tF4kbAx0FFutg7lZOZjMyzdCsCEzeErV5xBcejiOXHv2ZpyyjxhM8XNk0AUvJCAUyHhtFCBs7AF7FK7svq1LJgzztlKFFjM45JIiMJz6roD5rIgulnFIsSywvtc84AtSabEJAgoqmwhYwfRR9hrjrfUJbxBssvwKAd/TNiK8OBVVJGlyJASyenWl6fbPbowsTkZbHVpw3K22GnLOb3FgZT8A/KrJfmvhaQOEbZvticUFgcPxA4luuDwtTh0j+OQrj9N4aCVcBg4xFz6jIpnF8vmxrKEDO0m4X2Fc4wcUDy6xZt0i0iqeMwj75B1Kk6gdpQTvWFMjBIm32dhV2I7RYBx52cZKUloAIxN48g0l/qcSgfVaJ0OVyUdHq+nHaS7ou+beZBTQP93E3or0Qh219EQXosKEPm7aNCScnFkR5dvrP/8RG96Kqfr+WGE1IYRSlz5DENT6m12wnQfet8IDGJ/4LL7fykKmnoUBaNhFMImCiiUZD8kWKpEUaJYyeza7mA/bGy1s8OotDfHa2r2fMyFxN6t0O0hihQjCWey4wXFdqQeEY0NtbQ0FDMJ/EAP5exZ+ePQrkJ+DYbf6n2kQMS+aoG1UxGi5wGBsN5iAU9JiP6/I2TveeSXFGJYyMIN4gBBC3m4uvBwLh6KGwhE5+dBufBwNh4KrmW6XGRwUBrGQS3HiZPhsBtgcRW6nc2EAXgvq7JzmShsvrpUeJmBctzFnMf+6HSeGtL4/fuGi2ZIQo/UAvZUFQCo6qqhKn3VUI4G/iXtAegD0/yMf5vCftTFjek/4t/mYGvSi1WL1FUlsUAFdlenxK68Co28tO3KGAbWjGHqs9GadUEp+A1GWSGtQiB0yixjDTfyQ/HlkXg/1aKeSqfOIx3P5zWe9u1XCBJnkUy2IJV5JJeE+213LUShnh0nk4DMJYG6SaZwdd/15tRLuhO3H/cYl/8kFgem3uGFPAJJ9gbeSxw1NHlVJc9KuoVn3xkZp5u+z9+etku4nf5B/uxrm/vV6G886YIzwSKGl3fhhZb6tADU00q8XDWMCzwnLmrLcamTpT5ZBIm0GrgYWrO4XFJM50spGGdNKViGT56fp8vx5OmOb3+j3hA+Vq4eFxzaklFomgb18oaiRW8o0Fkz0pWA6BdAWvwKqwX7Sf8CSItXkGYBGf/++AadX3QLjQEno4c54XeV0W0BENEK9dckI7Tpss3i0znEj7sDJ05RISONBKQy3QplqiID7VPKiNP9f6mjssw/1pXRDw==7Ztre6I4FMc/jS/bJwlXX6q9zMVZO3W2s903fSIEyDYSF2O9fPoJEBSFre50RKZiXxROQiL5/c/hnDzY0nrjxW2EJ8EX7hLWQsBdtLSrFkIQGZb8F1uWqcXQYWrwI+qqThvDkK6IMgJlnVGXTLc6Cs6ZoJNto8PDkDhiy4ajiM+3u3mcbc86wb6aEWwMQwczUuj2nboiSK02sjb2D4T6QTYzNNtpywg7z37EZ6Gar4U0L/mkzWOcjaXmnQbY5fOcSbtuab2Ic5EejRc9wuK1zZZtNf5857vf2rDz+dEeLLpO3328UIO10M3/uWp9kxEJxVtGZ9Pu3fAfZv+Fvs5vOsbtU3fiX6D0qhfMZmpROxPsBETaPvohFfHBPfEpD9VKiGW2+sn6kXhw0NK680B2Hspr49a51Ju0BWLM5BmUhwyPCLvjUyriobQrR94MiWTDC4kElUj7Ox0Ej0fAjPql3TuqYcSF4GPZ4PFQKIVCFJ9Txnqc8Sj5sppHiOfF33MqIv5Mci0OQUDT1Qg5O0g+0n7g+itO8Rcki5w+FYxbwsdEREvZRbVe2AqZ8j5Lnc43Ul4LMMjJ2FQ2rLzHX4+8xV8eKAmUy8G97vHh6Aa27x+GF6uHh4/sabS+iUYO5yaH0psoRodP+AV/IBJnzfHXHjfajxtaFePWC7h7AXGeJ5zKe5dPzZnnyWVvyL+NPDT2kjcrBm8XwA+G8VQyP0KAi+Ct1AuLbwOMHbu4+Bt7DmPIQ3JEHrpdOx7tAo/vnX4LmUzO3R1JGKafHM28mntjMkF3nW3vEP0NojTaqw29Ym3AYo7Wp+FsIU13cb2EQC/N2N4ijPqTMfS9ZKp+fGpagUyBwn851tpjdl0p9bh8LA3wJB5svPDjqv5yhKfUuZxgIV0xvJHc7pNSO0E4VBO7FPsJPSIHuzLWrTHMrHIGl2jLnsef1sYl+IluaabzimCqwg9Rkb9Wwh8ekX+2nZLj79Lpc0EDGUFnyah0yUjb74+j1Hn7o7VhHVMHMyGHIZk60prHuISm/EDDBjrQrKQEej0WF9ACYAGnBC2xPeThU3j8TixGoIjcLkGuHxN58Ul9Ha7HLo2+8MDH8uGkSpOmPKmjPR3b1qWxxcQuIjFKkKAjIski/JkiQdtAIDgsLv4iIkB8Wz3y6G82//fTF7e/NE3ra8mm0tGqiQqrhv1VXOWbd+39Cy2HoZMpyeURDuMz96cd4NXs4BRcykKQbRRBGL8oBP35hx3RwVgMHh+e7tETc1aDQwR/bnng7n7s0TZXzJ28EB5WscEjykE/OzkYMP4rkUN2xU7uuOlfkUxqqBKjCRonCxqgfnIwz04Oe3PmquSwU2cemkIfUw1WExxOFRwOUEPVscFuEoq6JRSofk+QdqOSuqed6PQqgaCRSd2DSbUyKX1PUGteDXn3r4aUgtebPcWq9xRLOZhNmP7ZMH2AzN5nWlgqJKsR0jsQUg1SgqYK/R2FVGkJIk83P5JJ2nK/RNKufwA=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5Zlbd6IwEIB/DY96yAWkj15qt2dvPceH7j6mkEKOQNgQq/bXb4BQLmq13drShReTyWQG5puEIRpoGm2uBEmC79yjoQFNb2OgmQEhwNBRP5lkqyUmvigkvmCellWCBXukpaKWrphH04ai5DyULGkKXR7H1JUNGRGCr5tq9zxsek2Irz2alWDhkpDuqN0yTwaF1IGjSv6FMj8oPQNbP98dcZe+4KtY+zMgus+vYjgipS3tNw2Ix9c1Ebo00FRwLotWtJnSMAtuGbbxfDmWA7CcP8Lb28nXP3duMh1oYwacv2TW00MKGss3tw6LWQ8kXOmg/lB5oiRIP7ncltGWdKP8TwIZhUoAVJOEzI9V21V3RoUSPFAhmeIz1gMR87xs+kTQlD2Su9yUqfoJZ7HM6VsTw5pltlaSp0WGZabveSwX2rd5YgR0pLKboJtahuhwXFEeUSm2SkWPWjpRdP4PwMXwon45djG+rpLL0jcT1PKqzBKi09l/ctQAohqayQv4oB0+O1zyPKaejuw6YJIuEuJmo2u18JvIsrhOechFPhc5JiGuo+SpFHxJ9400Sag+C8NSL+ZxRvdcfAYAmw1CYIjV5uNYeAQsaELTxFTp7EBy9kCyzwgJvzGkTsL4HCisPSjsMNu30oTEqu1nbXBTSpWT+sA/Lq5dGqeiPNsKAqiBDZpDs37tQQbt993inJOQob4gs0ddBwbQoaIB9KBoGABodr5sAPgQItwDROqN1H1CVh+KhoH1KaoGYPcBBkDWp4AxOqkggL2p4WC7hPvwCqC0fQQR7gsiYMPOIQKHKgDYhyINdatGi4Qfw2sgr7fz2RTHf7799Ae7a+iGqCBLxuOPL6Xf7UjHaX/fnPT+OScXcLwWoLE3zs6vqw2oRqW5l6n4ie2vrDO0yu5vrZl3Zpu65myre6dXEB5Jg9zdy7mlfCVcejxHJRE+lcePXajn02ez4MhyK2WChkSyh+Yx/z7W2sNNls6HVz8YtdKleG49q3Vq3rLV+tgD7cwrQrPPVJ58T8/++nzEz+4T+P/cJwAadXybsPuzTXRkWYMRHjqw/hJvpcirF/kRy/gN17zqVv8bFurVv7Po8i8=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5Zldc6IwFIZ/DZc6+QCMl9Xabi+6dsed2XHvUoiQLRA2xKL++g0aKqw6g9N1S4Ubw3uSHDnPIZyAhcfx6l7SNHwUPossBPyVhW8thKCNiP4plLVRgD3cKYHkvtH2woxvWNnRqEvus6zWUQkRKZ7WRU8kCfNUTaNSirzebSGiuteUBsYj2Aszj0bsoNsP7qtwpxI02OtfGA/C0jN0zfU9U+8lkGKZGH8WwovtsTPHtJzL+M1C6ou8IuGJhcdSCLVrxasxi4rglmEjN9N1/G09zefL308/xcMcy03PTGahu3NGvV2kZIl6z+yPYiSdbPodPPyaJ2JyN+CzUTnqlUZLE9SvOk+0gs2Vq3UZbcVW2v8oVHGkBaibNOJBotue/mdMauGVScU1nxtjiLnvF8NHkmV8Q5+3UwF9ngqeqC19Z2Q5t8VcSyWyXYYVUze8aBOcwi9bVZLCROCeiZgpudZdjNUxuWFSvgeH/WH1IO7Onu/zyTExCiupVCYGNRkcvDmqMdANg+EMJPAAyQGKbeoy3wQzD7lis5R6hTXX93qd0kIkaiwiIbdjMQGUekTrmZLihR2zFCNmxlvhYMGjqOyXiIRdkE8P2qBGCPZtvd4Qxx5ABwEEgM10nwNI5Agk94KQ0D+G1EoYnwMFPoLCjYqlKktpottB0YZPpaqdVA3vvLkqNDQ1RhZoQc/gebHbCKMaOwT6oHoc4Ybc/7vOuY242aNOcRvabcdGGmFDncJGBm2nNmxEDXdqkXRA26lB51R5Dq+zPO9BBNpfoLunqNjXSUWXe+2HMuhCRd5zPkVJDkkXYEDsfIqtKmhWsXVrg2T//fD/8Ic9gs1qtG5tiNy212io4fuHTmGDpPWvH1DD9w+dWhahjVq3LA5OVdvoSvdA+CO3QPp0/11ra6t8PcSTPw==5Vpdb9sgFP01fkxkwF95bJKuU6Vu1aptXd6oTWxUx0SYNMl+/SCGxMRp665fluyXwAUu5hzO9bWJgyaLzQXHy+yKJSR3oJtsHDR1IAQejOSPsmy1xfVGlSXlNNG2g+GG/iWmo7auaEJKq6NgLBd0aRtjVhQkFpYNc87Wdrc5y+1ZlzjVM7oHw02Mc9Lo9psmIqusEQwP9q+EppmZGQR6fXc4vk85WxV6Pgei+e6qmhfY+NLzlhlO2LpmQucOmnDGRFVabCYkV+Aa2Ob3kyC4mgD31+XP2XkeD4IkHGhnDvzyklH7RXJSiLf3DqthDzhfEQPGbslia2DeAUWUF9dB43VGBblZ4li1ruXOkrZMLHJZA7JYCs7uyYTljO9Go8jFOI5ky5wV4kZ7VY7mNM9Nv4IV0jxuuVQNyQPhgmxqW0Gv+4KwBRF8K7uYVuRXQ9a1baIBy2o7JNQ2rDdmuvdkQSsLGt0XIN0E+ptUpLSgBuByVcJGFec0LWQ5lsAQCdhYrZ1KJZzphgVNEjV8zElJ/+K7PcpLRguxW44/dvyp8rUSrKy0DBq0vBMBvpakjjQDMBqO6lcUNPjxT/AD35Ef9MZCULiekkEnBTIAnvvpCvH6EIo6gLN/AucgVxGnXOJCllNVBtfGKiepN7xSFjWoJSUkmsM5fgFZ7yYABK0QBdyhW7+A1+ANBh8boYJWvHnjXvE2CrpOW9iKNtgr2kBo0+Z1j7aoFW2oV1HS5GTdZW30WJYNepBly7c5t/N5tvl40KTI6wFFwIfdZwg0GLp940yceCEK4mag24ezBJfZzvvHicf//MwcoHa5Qq8eOhE4euh8+kMGeO1yg3Gv36A6mB2Alq++vc7FO/gKBVq++vYqLgLv+IvF5/MUPpbbwT6k36hT2Tef0eV5NMbu5ezy+4/SPZtd3g/c57+xlhlequI8J5szdUon8SNFoovTOMdlSWObOltPEle+va1X/qjK0DfV6abeON3ua4k5xwNgGNhX1a4PIYOhC49bDarhk9IkGypu9V2rcu3OZO1wY6pi7usVu6dkKx6TFimfwDwl4vnPSCRJyZOb8ZnNZWyc5FjQB/sk9dSO0zNcK4nVgo9rn+hA3/ZQrVsPOjqXPHaFbFfhkasKmVOudgrYL/3/RQE+VBSgu6JwOyKKqKUmTGrSFVEAeyejV4gispOy4A1FIauHvy5U3Q9/EEHn/wA=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7VrLcpswFP0als7oiWFZO2naRdrOuDNts1ONDJpiRGU5tvP1FUbEUDsDmaaxEvDG8tELzrm6HAl7eLrcXiuWJzcy4qmHQLT18KWHECQoMF8FsrMIIGGJxEpEFjsAM3HPq4YWXYuIrxoNtZSpFnkTnMss43PdwJhSctNstpBpc9acxXZGcABmc5byo2bfRKSTEg3Q+IB/4CJOqpmhb+9vyarGduBVwiK5qUH4ysNTJaUuS8vtlKcFexUvwv8Rf4e/w5t8N5mpz7fZ1/DjyA7mofdP6fVwF4pn+tlHR2WvO5auLWufTCAYBNs717uKTs23Zv5JopepAaApslTEmSnPzZVxZYA7rrQwAryzFUsRRUX3ieIrcc9+7ocC5ncuRab38tKJRy+LsdZarsoQKoZeyEzP7NygIwOWqeIi+LYWApaOay6XXKudaWJrKS172AAfwfAirH8Cv6zfHKKH2otJaoFTRQmz8Ro/TNQQxBSsJk/QBx/pc6SLkuss4pFldpMIzWc5mxe1G7Oym5IVvE5lKtW+Lw4AY/PA4Cut5C9+quZFlBhBAo64Dk5w7f9Hrskzc31mTitGq/R9QUxmDigZQ4oAAoBww/rZSacnSPfTItGscpaZclyU4ZcKNZPUK/5xNYg0renDgwVaMBdWA4YN7egFqH9OyIb8l81LfifZyKRXsoXYcdXGnVRDvVItGDsuWtBJNNyrDElcFw3ix4w17IGxHkHkvrWG5DGJSA8kghS4rxB9W458RF+FJYf+26IdYvoqaO/ozvq1FfprF0vP/2Tv6Mf6tfVxfb8Kw27nDL1SDQbIcdmqsdvOGXqVEyFBjuXE6lXLsZVGfdjtYPc3OwgPRz/t56wYnH8pkcFetJ6sYuDek4oOBqPVvbuo2/Amo9XOuyjbeJCt7VTcRdmCIUu2vYFyUbZwcI+t2zAHzCMGg3lsPeV40fVlfh7+Jrivq/3bEl/9AQ==7Vtbc9o4FP41zLQP8ejiG48hSduZbbqdZnfSPiq2DJ4Ii9omQH/9SrZ8ETYYCE7dWeAB++hmne+c70g6ZoRv5uuPMVnM7rlP2QgBfz3CtyOEIARj8SMlm1ximm4umMahrypVgofwF1VCoKTL0KeJVjHlnKXhQhd6PIqol2oyEsd8pVcLONNHXZCpGhFUggePMNqo9hj66SyXusip5J9oOJ0VI0NbTfiJeM/TmC8jNd4I4SD75MVzUvSlxk1mxOermgjfjfBNzHmaX83XN5RJ3RZqW//74w6vvsVz9ulhkmzu//r06/uV6myEPhzTqpxkTKP0/L3jvNkLYUtaKCObcrop1JwpispewAhPVrMwpQ8L4snSlTAsIZulcybuoLhM0pg/0xvOeJy1xqaPXSAbMvJE2aTUfFEl4pHoaRKEjNVaCSxcaks5j9KaHGQfIT9QK0p7LzRO6bpmNUpFHymf0zTeiCqq9AqaSpOb0k3y+1VlYhAo2axuXlgJiTLradm5Boy4UNgcgdMBMNHIv5ZOVenUJ8ksww3qGEn5V5KmNI4yCQK4RK5wJKGiiQ58A1kXEOK5ncgehxT1p3QvTjUYrBYUCllMGUnDF50p2pBRI3zloXi8ygxKkivMwN5CN+HL2KOq2ZbnbXfW1VdK4ilN2/rKjKWc/en2YzXs54sIB0ICG3YkHCXV7YWwcCotxRMIUoHsRLpTKHj4WhXMQ9+XzScxTcJf5CnrStrMQk4pm6Q1GVm3sq9lypM8ksBuUtCdv6SS/pwfWhpSLjBA/QMbVNBmg6hHInBbiMBmErBkQSINSfvnUgaoiZdr8Fp6xfTpnXgAMTQoft5n+gRS1VcBmYdsk1edUfZCJcq18hw4WQrRYl0vyAeVJRGP54TVylZKM7LQVPABRiX9XIln9sJo2mwpjfBK2d11Vj9IayWh4KVI9QmKJ8lK0phESSB6KvpUHARWPPb18cqGfpgsGFHzDiMWFm0Cxkm61VGhVXE1lb+3YfJcQCAQzVHIi3a5VkcIlVpTiy1oHusjADjA8/r0kZ3M+Bu9YnzximF5xT2dcwntYPzCo2KVY76pX+DD/KLPZSOEOx1D6keCmWu7QrCy8AaonT7V5g6NXh5jgbIo5QsaiyUaj3ZaSSnOn/X3GU//Cw9hGYaNdPsZN+3HabEf8zz2w5O7L/98ifm99/N5+TgWM/r27co8YNvBmNjv024ESLLIDwGCcC03FXu2irs2g0dGwt63iu7YwI4GGgKWYeMGbq7hWE3kKmkvvm91g5fMyEJeehsmg0eMu2F8yjeFn59KQYnH38s0jxL5SUDubbaBHORgyxpbDsAQWSchX2xBVMQbmiFgaOAt7zWhgaymIWBj3GYJPZuCPQhTsAxsi69wEqEe18TOfls4DvPBnB9JW4CW445NB9uuibbsAiGj3SxUdQgsVDCItkxwjD4txOlYQefBF349dEl31KHhLvD28IQM52o0MEBCQMIITB14pxnOkd2yTeoTZfcglM3JBeVDUBZeO0SQx4e58gXjUz25PbS34dxvWC9OVLrc+YL0id48GKDhKemfGlg6stt7YboO0++yzLDU3Q9VU17frus3m+ImEnOrNZK3P9Ro2U3VLLvb1MZuyyHtzi5pWaxm6iof0P8QSpXWElX1RNY5E1R53ueApVSe1DmAqIeS8ioPcssDCOsVKa/t0zDTeuucFzIPosfH689vQZDUDVBA2iy9PLLfJshpTPyQav6iXlP4E8IkAk3qtKtaWuq8T+50Ltz553CneyB3FkufoXDn2BWGXUsUY5383Fe8PNDRda/vErQeCqPLofBZNgw9Hwq3Yocv2O19/aPSfhnFXAMO40DfNI+KZB4jSRJ6RwWzMjDVw1ItSr02MFF5yOm1xpltE6E0CLKRBMMXiyIepzM+5RFhd5X0jSMUbEaofZ42mMW9q6/HMegtJCHLMgB869W+2wxL79D7poMIPD5Lg+nvFbfTEhX7z01eQYMlbWzzYPlitpqN9nJzKz8CAwJHz2cUjvNK+4R6r0hvz4MgoX0tZ9y+WfX3suOpnH5OVu0kSzRsskTFPyVOOwkRC0I8rj5bpl4lBLvJUlgh2dRqKvLZMxNrx0z2PbC1fXRjd7cptLyzjbjIn/6sztvMdbyD/zPS30tq5+B84BRvJp3qV2/C4xAMa2+zC0HtTOacLPvq/HT5BlpvGx1xW/1rKge++msavvsP7Vtbk9o2FP41zLQPeGTJNx5hN0k7k6TpbDvpPnWELYNmjU2NWCC/vpIl+c4CWeylqdmHtXR0sc53ztHRJxihu9X+Q4rXy09JQKIRBMF+hO5HEJommPB/ouYgayzLkxWLlAaqUVHxQL8RVQlU7ZYGZFNpyJIkYnRdrfSTOCY+q9ThNE121WZhElVnXeOFmhEUFQ8+jkij2VcasKWs9aBb1P9C6GKpZzYdteA59p8WabKN1XwjiMLsI8UrrMdS826WOEh2pSr0boTu0iRh8mm1vyOR0K1WG5q4GP4e/zFJV+Hnx79//fPxsB2rwUbw/SW98kWmJGZXHx3KXs842hKti2zF7KC1nOmJiEHACM12S8rIwxr7QrrjdsXrlmwV8ZLJHzcsTZ7IXRIladYbeQBj3+OSkEaRro+TmHefnbkypYFnkjKyLyGvlvmBJCvC0gNvoqRj01LaOOSmLsu7wkwgUHXLkonkpo2VaS7ywSvK5Q9KvxfoGp3WNYmDqXCMQkcB3iwz5ZtVRYv6L5gxksZZDQQoV792Bq6iWRW94/BchgUJFuRFJEqKtlv0rOtSEmFGn6v+3KZ7NcOXhPLXK4DO8dJAOzX8Nsk29YnqVvOP+mCnxmI4XRDWNlZmDvnqv99CrIaFfOZBm9eYDUvhrsCqFoEjuhC24HMECYd3JhyG8mg5VYIVDQLRfZaSDf2G59lQwirWYknZIu3ZyL4XY21ZspHx3uzSUR3XAGBS+lQQ8ACXlj5mw4nbbAt26MJ2iws7kQBis8ZxBSHnn63YHma+dLapsPbF/Cf+AnxqoP/9nGmXb30xG4d4RaODbLok0TMR6JXkEhAhNeF6XxbISYUkTtIVjkqyndKMEFoASElEROAY83f2abxo9hTGNVb2NM3ah6wkoTyixGpMoN8kk7AUx5uQj6THVHEe7JI0qM6XdwzoZh1htW4aR1T3CaMEs9pAWqv8aSH+39PNk4aAIypRkKJjLnNiBxNaU6mOafFyhOckmuUJQ20LE61L4RQAF/h+p1vb5EiUekOvcAavuC2v+ERWiYD2ZvzCJzw/sXr1C9T0C9TiF6hDv5icTvj4yWItHv1DJOwnRaeBmMuM7uM8r8hB+G3LpKHIXFyi5RjQhS6y7YntAmRC++w0vTgWFdlFbvRd4YhMA8EqlJZpQLuBpukVLcuImo5nuHZ3qOo08Y1htQ3k8D8e2LmCPAu5L+Naw+8YzL3iCqFxPqzINboE1Ty6h/kyBW/uYW37Bc9YeQRvBGSuUDY2jTmNS0FZDnwkKF906q6hSbwQhrjNHPL8JIvmajbQlseIT6f2AC1DJ/TaHtxmyHaLVn1lMybs3hSswRQKU6iTNS1m4PWc0ZroREoroTLPTbG6gbDYtCsQduaygEdmq7Y1txBrTsue3CVW1llYWf8vrNA5KVTvUNnfQ4GW1F3Fpn4kIXvK/hIyw1alR9VSPN/vy4WDLsR8baVOovioZssKRbesdGiPkjm8x4GvMLlN+lZOGLynQqUlsrZM5l5mLpL7PCPpkcTmGeHwVmjfnPTQ5j2xX0H71nlfy+6b9zWdK1/D1NN7QsKwlf8nlouctixgkeKAkoqN93BIaCaF+TZfPiI47VmhBzs9IrhD8Lql4AXPDV7WbQWvicezqNKtRm2n9l5xg3Vi6P4vtOBVLkwKdrggiCE4whEXAxVscekQBo5Tx1VZgz2uiOsEMjzNIesmdRpZ3ddVxHUuuSJso5N1g3ZGWUvbSOV8WTVeuXFw/Tr9eH1Gud+7E6/BQUF03vVJlzQxdE8QDlLLE2MnrGjgDASUCJyE0emZM4DeEOt+lFhnGMZ1Y11njmBDw3FrGbP99iFt0imHKkxmP1CoL7PpE/vsg1OXYRGZZ+1uYNjdypSEfTpLsXIytjco4UBTtMLT8h2cnEXqK+Si41cWQmli18N+NeKukjjZZOA0IqzuOk/rNfzl5Hgd+ObFBtDdVUcd4Rby3O7Z+6wB4KsB7Nr1q6ybgNgeIL4axCIxrnx72L09vJ3hyDgcGfs+Mta+bwGdt6fAkDs4wg/FE4Np6i/FJcl/mzGGte9RtPkKTyX071Ze7y68WPysUN7CFL/dRO/+BQ==7V1bc+I4Gv01qdp9gNLFks1j6O7pvXTPZjq11TOPChbgbWOzxumE+fUj+YZvgCDYyEHJQ7Bky7bOOdIn6UTc4Q+r188RWy+/hi737xBwX+/wxzuEIAQT8UembNMUy3LShEXkudlJu4RH70+eJYIs9dlz+aZyYhyGfuytq4mzMAj4LK6ksSgKX6qnzUO/etc1W2R3BLuExxnzeeO0754bL9NUB9m79H9wb7HM7wxp9sJPbPZjEYXPQXa/O4TnyU+avWJ5Wdl9N0vmhi+lJPzpDn+IwjBOP61eP3Bf1m1ebTb4tsVP3//5L/C75z18v//t07fRKCvsDv1yylXFS0Y8iN9S+ohO/s0ePse/PjxMf5t/mS6m//s2QulVP5n/zPO6SN443ua1zAP3XoIljoIwEIlTl22WXJYKxcEyXvnZR5n+wOKYR0GSggAWqZs4Cn8UAIm6myY1nxQAivwPoR9GyQ2xAxibOSJH8c2zGuLuosyLrBI+83DF42grTnjZcYRktbUs0SNPi7jPYu9nlWMso+qiKK64w0PoicdDIJPVqJBHpiqEJmMLV4vZhM/RjGdX1mCrlYfx8eJiFi143Fac+FCqg11Swo0TWEigIUrXRIEUXIwljbK6p0izKflV9DgJtnWmxPw1rjKC+d5CcmEmEOQC3ulPHsWeaOrvs4yV57ry8mnEN96f7CkpSrJiLV8peUkyvSMfZVnPcbhJOytZ9DwM4hJpLFfwBpxMGvk8/PUgbfJcgCpQOGAMyj9ZgUdIhsB+PtXBOxUpvA8peFtIjWBNgfpBZe2DyrotqBBwNEeK7EMK3ZioqOZAQdoSylBfIrJZs6ACFf3/s4zxp7O0Au9lr794+pt4AnFvkP/5e1KdQNb0aM5Wnr9NT11y/yeXMJbyU2RkLkTr13JGelOZE4TRivmlvJesamSmlaEHfC4DqJF45pkXLJpXSpaNMmLdJ+fP41KOJyKrICsT5E+S5MQRCzZzUVJeZhLLSdDCyK3er7jQ9TZrn2Xv7QW+l18z90MW1wrKa1V8Wsi/H73NjxwCAWmKQpq1TzsvSy/mj+JRZPKLGN5W9SRrLRuvQksee76fiyB7DJ89cX9aDARruTXVAGCD2axL1TSCQZsoKQV3qRTbKEUvpXzlq1Biq7NWZlyE/FavWslF0I9WWidS4F6pyOqR8Kb1v8N0x/kGzEdV1iaQRimPAVtvliJpH12K5PQRL8uivsOOxrSLdX1SEP1I8d+1y2IZloZrHrHYC4PNbfIDgyY/7BZ+WB3ywz4+qSZb3HWtVU6nqx1O2ybFippshDDy5+01XEznZ4OQypR4+yjbqjXXsFnzELSOAjoMbhTqvjr9eITgB4DYA506QAfJc1wCfdVz62OC4/W8WbK1/Djb+jLWivDx2n5KofnyVCQU0cl/nuM0qEphSdscOkY2sjEhE2IDDBE5C7F8mJ4FiL0BmOU6Y+qUx9J2VVYAjyFuKMvB4wlpYu4443yE0YW6HIN6P6hjOEZEE9AnWoBOxpiKX9GqIWg5FrYPo15H99qNdQl1S2iaIIohsauznxCN2zG3bLy7rCXWtccdwg/BkemCNICED6rj15P63/MCpMfsbuAKEEOBMZmUfqrKps0oCdGWzrtLRKESotbUIJqOL+mYUu1ARGqyNBiqqLK9v23DtNu+FmI1aRpU9yhTGyCtc5w1JTCqyNXnWfirF/8u88YkO/ojO1N+/vhaPtjmB4F4t9JF8vCP7G7Jwe6y5GjbDmphz9lv3KkYhJquoPSG7i+erNKSB6jsETqNMamlRiGISf0yCs2qNm6impWBnO8lqk2Ukb6dRNZErcd61LRxW0TM9XhFC5m9VLvuDGIyblmT7ztGIWpDB8sgfk5XBzG5PsJqUej3+y99QMydOZqzNoiLlf4Bi3rShJvCMbaaiMMuEccnBTYzn2023uztsQ08K7YBl4ptuJyDmbWGKvV2hvP5HFwxhMn7WU1CGAtWWV0ltX2+OfpwwaR3pzSxjDK6UIYmPKaTsbWfbm8IzA8XDPsP1AkxY1edxq5QdeyKTcPfccPfCqRzE34PDK9r92it+snQ7R7OMOwe0Pg93o6g1n6Pdtihgb0f2K9k+GhHHRnHx0Vh19fx0Y6/2iIkeqeOD2fQjo92RC0lRPHUIKqF46MdRKImS4Ohpo6PdlSpmjQNqvo4PtqBtM2sWQ+zZk5z1uxgEFOeNTvYrBrHx8UnxqCj1mPd4Pq/M3jHRzviah4fbBAfgOOjfWs5YBwffYm6d8dHO+LQrGtfdF378iGMYxb+rrHwh5BRRhfKMI6PvomMzdhVp7GrpdrwU9PwX6Ph794DW7C/0oLvpHCFNlySLA+kwyhehoswYP6nXepZOj/Nx3JUOkTRK0U0+z8f6OzZx+YMtYwmjhgklJaacXULJbKbKuhPMp2bY69M/TO7q9Pof5zWQDNa1zYJwugNtIYQHuQ1QuP+I6eb2OzJARp6/5AzdPMfGshmT2hibGBvh3B49j9sXJ994a6T/w9D4/+7LO4DMwBitf/qxe/UAIjs9+cAxIqezqmBVGMLILZu2SyG7HfqAcQ37exE9vsxAWJqFlJ6WEhBtuJ0cB7JHF1JyVtW4wK8/GKJbTxhffVomtgAsTF+dtnb6eADxBPjA+xN1noYAS1g7E4XtTt1EMbYxhByDUOIZTyy3UjDWAH7ZjIyI1itRrCqJnBMTNN/jaafTG7BAQInOlpAKBi6BaRgj+YWEGp2AroAhMOzgFBkcO8Jd50sIBQbC8hlcR+YBYSqrTRb79QCcjrG+ltAqNoqM5waSDW2gFC1/YIsA+KgLCBUbZEUGlh1t4BQx0yg9TCBllPm6AQaVf1nWkqNBaSjOTKqtlh8i18EdfEeTRMLiK34tcEG8sFaQGxoLCC9yVoPC4htdry57Dp3B2GM+fqvq6wD2uaL8bqRhrGA9M1k893Veo1giWrTb9x/12n6yaA3tzlzr6njm+Kcv7nNwfGGNpvbkNq8Cjy/ExDhw8G9bRxlUguWsW3pzLU8Z7P/NerOnuIt9j9s/RKU2xXKykqf47I6s80mUpfdRGoII4iWTaTO11kyzKYlnTnn7yF1qtJQTtf6exx43NolRa95ttLEYRSGcfn0iK2XX0OXyzP+Ag==7V1bc6M2FP41mWkfzOiCQH6Mk+xuZ3bbTDOd7fZNBtlmFoMLOLH76ysZccc2voDZDc5DjARHcL5zjo4OX5Q7/LDcfAzYavHFt7l7h4C9ucOPdwhBREzxS7Zs4xaiw7hhHji2OilreHH+46oRqNa1Y/OwcGLk+27krIqNlu953IoKbSwI/LfiaTPfLY66YnM1IsgaXizm8sppXx07WsStFJlZ+yfuzBfJyNAYxz1TZn2fB/7aU+PdITzbfeLuJUtkqXHDBbP9t1wTfrrDD4HvR/G35eaBu1K3idroP1+eRp+mhh4EHPA/R48fqDVSwu7Qh1OuSh8y4F50dekovuqVuWue6GL3xNE20TL37HsJljjyfE80TmwWLriUCsXBIlq66qtsf2ZRxANv14IAFq1hFPjfU4CE7iY7ze8EgLT/wXf9YDcgpoAxi4qehk+uNMTted4ulBI+cn/Jo2ArTnjLbIQobS1y5pG0BdxlkfNatDGmTHWeiktHePYdcXsIKLcape6hvAqhsabjopjQXwcWV1eWYCvJw/i4uIgFcx7ViRNfcjrImna2cYKd4MFO2rYTaICrGUlFVvsWQioW8ruYcEQLrFhKxDdR0SKY68ylLVgCQS7gnbzyIHJEpL9XHUvHtuXlk4CHzn9suhMlrWIlH2n3kGRyRx6lrHXkh/FcJUXPfC/KGY1uC7sBJxuNvB++OWg2Ca4QEs0wC3BQoIH8Rwk9YmgI7LepMoCnomXsQ0t/X2ghSHqOFK2JvIYrEQlXzCtAZfy7lhnJxIoVeC+D1Hz6i7gBMTRIfv26UyeQmh7N2NJxt/GpC+6+cgljrj9GRvZCtNrkO+JBZY/nB0vm5vrelGZkp67QAy6X8X4k7tlyvHn1SmllI2VY97vzZ1GuxxETgadkguROdj1RwLxwJiQlMndTj8TMD+zieOmFthOuXKae2/FcJ7lm5vosKglKtCq+zeXvRyf8nkAgEI1RiLv2+c7bwon4i7gV2fwmkvGiP0mtqewa6uLYZVPuTtIcNfEHdUclFwHABJbVZkCrTFQmaeQVuEWvGA9e0S+v+MKXvoS2N35hcZFW6p36RWLwN/SL5JZqHEPqR4IZaztDMLPwCqhHfarOHSpSngP+6vjrUErw2CpciN59dpI2x3d7VfPpPhMsrdxMqFFaMRHYuY3A/tnIXyubRTL/9Fc8EMsq33sfJpKmjomN0GoMMQ8sQltZGzQoCskILHU5c1w3p7DZbEa5UbdYT1VZSV/k53IVp1VGtdooVOrqVA/HpegNq5qHoDbZb1P3DQotxbLIEQs/AMQe6C4EKLWe405wW03rxzUdLthKfrW2rky1Anxc39MYnM/TtCHNV/5YR3FOFQMThx1DQyYyMSFjYgIMETkLs2RFrvLD7iBUvVQzaH7ZXCx/QIA1iCveRbE2JlXUKdWSBUYruJMB945wx1BDpC+wG72AnWjYED8itCGoUx2bh3Ev43vzkJ3DXRd+TZCBITFp0d2RVo+6buLsspqc19TaNADzSMkgTiT156Zr2JOm4fPypBc1GrgFxlCATMa5T9G5jWq6hIyaObxNSGkjSOFkgFStGgwtiYM9QnHczDEHEBv5Zf2kWwdquxOuCZo55wDrPt/sDZLwnJf/OTSK0JVrLnzjRH/LPo2oo2/qTPn9cZM/2CYHnni23EXy8JsabXeQXbY72tajmjII9nMLChyGKnEhHtD+4EiV5mgKeRrDiSYTv/ZvkMnE7/QbRNbeMB6KFRdKzuc7FCVh0jXbwdQbRbev95+7iG+cztCM1dlx+nawHN/mAbMdXvAGRYHr35Q2rkZBA2pYr1oqbDMMkpPCoOWyMHSs8yIhyodCeFYoBNcKhVwu26zayFaeZjmfzUALES/xtqMRj+JeRTwdFu26aNbmBXwvIdjI1V0oKr2JJBqAncdEc8gTepUn0IZekxjiz+41hwWTzimTtPqyByLtjblDcpBPDoiGK+GtkhDo3ScE1GhWuHgZlrhZmpeftRCpJy3fsBhFm1WJ4YBpUrboP6YmbTtxbzOXzlKYQnaf5TN7Uhg5mSeW4QfRwp/7HnOfstYTGRfHswi9X9WGlFeVltPOrzeMTCyml5yZ43rWzvHcQVgZ2+bOVIz4vY8BzT1Psf9my5eg5N173o3i+7hqOgN/eO7KGRQ/vY8sIjhwW64IsVhslxJQ4VH9IbTAgdDSKthQ7xGNBQ40lmujLfkrCTWlhDzqJZMFNlyj/KRMljNgRllxYFvKkW64LoHN6Cv6ZMAxxpHiXsI4fs9Eh+t4o94TqgMC75mLdBWP7A2UA2uli7dRsOHLKNiUtAJ7RlpJK5iJgY8vKCPB8p+M6p0zV9DAXGl3MkOgF3QV1D5d5cdlnjStaVPQs2AEaGkzKHBBMAL0YFFbvwWJBBmD2V5utqhfZpswiK9htaaA7aDRdm6xA+2pV4lmU9YT6llsHx+MxpBe4DNHRHe/WRytrrPNn5z4dE5uaWqwZjOyNNRVa1+y8Aw7ZkFVd4ugA5TlOgkp/3FPLXowPasr9HS9u3TrNP5Kq5yao9yYc2bda09kTbM91DfiDS1RVkBrUxcip6xRTuXeiCchN2HSkGbMUvwy1KGTqbK81dbt3wuRZq9p0QBiMkn2D0NK+7dV2m+eFfClUL7MsSo76k2Dmp3S3tEee7iOspGucDrbnhQM+6W3vq++IaDOL4+M6+2xf0T0JQtkcZj944j49Oy/c+Cn/wE=7Vxtc6o4FP41fiwT8gLh423tdnfn3rndcfb1y50UomZE4kKs2l+/QQKKsLX1XqoZoTM1OSQncp5zznMg6gDdzdcPKVtMv8iIxwMIovUADQcQuhhS/ZJLNoXEw0EhmKQiMoN2gpF44UYIjHQpIp7VBiopYyUWdWEok4SHqiZjaSpX9WFjGddXXbCJWRHsBKOQxbwx7E8RqWkhpdDfyX/mYjItV3Y9c31PLJxNUrlMzHoDiMbbozg9Z6Uus242ZZFc7YnQ/QDdpVKqojVf3/E4t21pNvlt/LiYfQ1HAt1P//39BQj4641RNoA/vWdWdZEpT9QP147MtGcWL41VR3KZhjyHLV5miqfGBGpTml3xtX4jt1M1j7XA1U0Wi0mi26F+i3oCun3mqRIaqE/mxFxEUT79NuWZeGFPW1VA9xdSJGrrBuR2QIa5rqWSWeFquepMpXLG72Qstd5hIpNcy1jE8aFIJsp4qIvLvnnPwPTLKRpuHCEKcvkbrWtQyK+Lr/e8z5j6gcs5V+lGDzFnS9dZ7RzTxUY23XPKchwzsTCpNNXQ1A0D6HvA9ZvgimTWQ/t90CISOGWOOSe8fjN2G4DqzLXIm+OYrz/lKVfbhSeRaQ7DmGWZCOuQbxMjj4x16yhp+1LAWEjbocoUS1Wp3Mi09dPNX0bbtvN33nFI2R2u908ON/u9R54KbbDc84bvxzQrUtn/jws8Q1ssnXCj8EaNfoH/8NVk+flhPmfzP9hv36pQ4tGEv+ojew5BWvyhlKU8Zko814mszUnMCo95MO1llzJvbw76pYriys2sA1440IVIXZcb+E6AoBdopX7+n9ZVF7ZqU7314soWpzt2icpbHDvcxEJ7a4q0c6ymQvHRgm0hX+map+7XT4Vff36qBFUZ8HWptJoqMZlk4zmI0AATiohHqC6OWnLRXgwUVQTlXlvUVFmpOFPWK24zf4Ht0WH+ujkAHJFGLoO0xXcRID8kmbUGGETHMddqdGnJjyPNskVRb47FOk9kNdjgO+BBr0D80bBhR8fk3uHVoxZQB3lNUvJbgKyEXQBJjuOYx9zipODpyObVLYopX2plfhsWFdeX1veaMeQDnUabxu/S9m/Im3VyPxJHrwDx3UHxqvMcD4rzGrpZWA9FNjsHSXm6FIU+IiQgPkAuJG2wAeCDMGzCxukYjtlHwlaeRQ4MAuQTYA6/Xs64DvWbEYWxg/JLLCe5LRwVOMjvkKZoA/gvfC5L3R8LPdEJX//pXKXzEcX5dbdgH3IIUFupwvl4DC4Pe+qchjzUkYD3+RF1WKzgayA5ghzq1uMSXwTNQWI7z1UOdOlEB72e6U4Eznaqg37PdV2jbwXZ0Wsguxt0kXd0MLCe6qglVNeyFXbdVEevhuqQ21Nd1+jbQHUIXed9Hb0IrkPYdq6r/OfiuY70XHcicNZznddzXdfoW8F1fr/J3uXnv4KDTXbfefM2O3S6jH/ab7Qf+XyXjlRYD2jXBQ69hN11FFxDhYrp4cOYtug5Q92EgfUlamBJiYrdvkQ9ETjbS1QM+xK1a/RtKFHxVTyOQUHLPvul8J31j2SwLY9kcP9I5lTgrOe7/pFM5+hbwXf+VfCde6k3d9R6svNtIbugJ7sTgbOd7Ajoya5r9G0gO+Je6c0dvRC6I9D6bwu5ltAdQT3dnQic9XSHe7rrGv3z0p3u7n4JpvgK/O7ndtD9fw==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7Vddb5swFP01foxkcATOaz7WTuu0Vpk07dEBA1YNFzluSPbrZ8IlQOjDqrUqUstL7HMv1/iceyAmbJUfb4wos+8QS018Gh8JWxPf9+aMu58aOTVIMF80QGpUjEkdsFV/JIIU0ScVy/0g0QJoq8ohGEFRyMgOMGEMVMO0BPRw1VKkuCLtgG0ktByl/VKxzRqU+2GH30qVZu3KXoD7y0WbjIX3mYih6kFsQ9jKANhmlB9XUtfktbzc3z1sZpybH+sHkX7b3O1uf/szLEb8Ly+567ILIwv76tVZc9dB6CdkjYTLCswjCde4d3tqCXU0lPWwVkIawpYJFHaLcerm+1JEqkh/QukAr0as2LXcM5xfOG8T7mGvrILCQVomLrLMbK7rhLqkNfAoV6DBnB+CcSpExF3kH3lB/g7SWHnsNQaSdCMhl9acXApGZ63q2PYMp1XXQwFCWa995ogJ7Nr0UnggixugMi9QaT5SKd59UHWuxOHvL07wnIUK9zb9Gk/fRInSuocn5wsfqofT8/WGsgZDWb0JmC4c6VoJPU05KQ1pFI3llDzxE/EOcl651JuATfmnTV/dplP4Ni5GugoTZeogP+gH8lqiCVivPRB8eu9/hF1c/S19U++5aXe8Ocd6h0S2+Qs=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7Zpbc9o6EIB/DTM9DzC+YZvHhOSk7aQnacgpbd+EWdtqhOXYAkx+fSVbNjY4AdJCPBn7IZF2dd1PqwtSRx/OkqsIhf4XOgXS0ZRp0tEvOpqman2L/xOSVSbpG2om8CI8lYnWghF+AilUpHSOpxBXEjJKCcNhVejQIACHVWQoiuiymsylpFpriDxZo7IWjBxEYCvZGE+Zn0ltzVrLPwL2/Lxm1RxkmglyHryIzgNZX0fT3fTL1DOUlyXrjX00pcuSSL/s6MOIUpaFZskQiLBtbrbZExqOr2B1Prm07Bi+3bqDeVcW1tH+PSRX0ckIAvbXS9eyXAtE5tKon9ECfQQUcqmuXsn+s1Vu89RqIIpUOvr50scMRiFyhHbJRxmX+WxGeEzlQYImQG5pjBmmAZc5vAsQccUCIoY5yOuNBIyKEhDBXm3yM6mYUMbojCtcTMiQEhqljdNdANcV7YpZRB+gpHGAd8cQOWjASnIl/bh8TytLGqJBkJRGoTT5FdAZsGjFk0itZksw0scsGV2uB6yay/zSYDWlDEkf8YqSK5R5QII+ALq+Bf2MI/SByz55ASfKA3fgCSR/hP9wCs/xPBadrrWTjqacmI6xRWfog/MQUsz7zueuuetyp3jnYFRjJ5hTe429xeVmJKrii4imUOb/dShgWLrpNAiKsXsuM08MZbAFZXx23dFMwus+n3AippeG5u5795his/I8HOPEcFR1i841DuYJF92KrZ2mDLNl532T6TdvLlO39303iz/jsPdWbOe0drTpq7/HYn80Du7Xu5/+r6dxSLs/P4+ejMC3xt38JFXi8AIFdc8d93lxvCkDyQ44LwJ5BuHJQamvmsq0Y4JSW1C7QQ0aAEprQe0GpapvT6qd+l73c4Gh9/TKZ57Yw1pu29x0bYNK0ym202QdRdPsmaXPajpFvaW4ew4dNI9bv+V26BzaQIpmS/FQirUbzzfGaLcYD10K3xjjXffu7hHM++uvl//fDH2YDZ/c9jyxz1rYRHBvcKBo/o+Vqf9ZDVoBF9fjZEH/WzmLH9/uH8f3XvLJ7up1G9Ds8iUOUVCBaD7OxXuJcyez4hlXRt7kA28Br1vJ//2T2lQR5u66aIbJKkvqA1mAeARQ0sfpixShVbUwKSuySoUmoNEMkZJuKU0jlIZEqBBgDKIub7ODA287J4fGuvJZgtAVLxNyHebDM5ClKnlbUg2LUBC7vKy81AAy7ZJG02qNRUaXUMQ2009xHBIkzYEDgqUit2t+1zWkoRhHdPILHBZv34XlEg48Y5SLN3xOtP7VziabveE1xdXM0aa7jfv84hq55DMDtXCsspvox3QTo12bGr821ZNrT2qvXpxUwe7EuPY4ksU+CkXQJZCciVeI3FAQTGXwwiEojrFTpVa9CYUEs+9SI8I/hLyn9WX0Iimlu1jlkYD38Xs5kmXr59F1tjSW5xNsR7L1NfesYLuai+pGja0g5NhZ5/LnkaraMzS7b6n530Gml287jZ6llZS2aFsO1OxVMtrmweMrpvPIgT2mSYYiD9geXglTD14cr6XR2K+53shlERDE8KL6rLRufMoabuVbrGdWHWNjhGcdl5k2HmluFKVvvOIobojzsjLb1JWVOkzR9zof4tH1m9Us+fphsH75Gw==7Znfb5swEMf/Gh5bgZ1Q+pimPzapk6ZGa9enyYEDrBrMjGnI/vrZxCQQ2q2VmszSSB5i350PfN8PtiMcPM/qG0GK9AuPgDnIjWoHXzoIeS4O1I+2rDcWf3K+MSSCRiZoZ1jQX9CONNaKRlD2AiXnTNKibwx5nkMoezYiBF/1w2LO+lctSAIDwyIkbGh9oJFMN9YAne3sn4AmaXtlzzfzy0gbbGZSpiTiq44JXzl4LjiXm1ZWz4Hp4rV1Oftxf0+Wyc2jt4awqtNv5Xf3xCRz0PV7Rm1nISCXH54dbUY9E1aZqs0KEqagbJ+TnErduIOE8txUQq7b8gpe5RHo5K6DL1apCl6osdq7UkApWyozpnqeajKyBPaVl1TqVPgyVJMBoRzPICRVmt3uBUiuMxBGkxfDZ8ax5FLyTDlinkuDoId0nzI254yL5mZxDBDH+j5LKfgTdDwhIBdPTIaO3W0+yv7G+hud9A1C3QHQiHEDPAMp1iqk9bZ0mcfL801/tYN1S2DaAbWNI+b5SLapewCohmHgHTzgAQ/zFMKnglM1eeQuqzhWOtiNwp8l7kHyiuSvwXMoFPD07yj4RyZhMiDhYXbrIJ+pa18sRQ8A/2ell8KmnidlU+CZCvBQUTdVa/2qlTTDq3hk6IMZmrxhOZkcmaHpgKGB7K8JtlViX6KNkh0W1OZc6GRZnehzzOmSlDQ8LYhUEufXSoW75nDRCLIwF44oSRqVQSW7nG69WvT2rOCeop69K2bzeQmTqae/L8jfjtjDZRe/h9WhMNnqbTBB7tsw8Q6Iif/fYRK4hITBEBMIYhSTI+KAXftwOBtx+Fc4oP1N5HyIAz4yDsGIg804HHt1OB/PFNadKZB9m0ibe+TE4rOnZwEn3siJ9euJDZygkRPb1xMbjideMHJiGyf7f3Kt4GQ8x1rPyWH3HdXdvUFsfJ33sPjqNw==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7Zlbc6IwFMc/jY92COHmY4u9zLY72nVm2+5bChEyReKGeNtPv4kGJMBWty2udpYXyZ8kJL9zkpyDHehPltcMTeOvNMRJxzTCZQf2O6YJLOiJH6mslGJYvY0SMRIqbSuMyC+cV1TqjIQ40ypyShNOproY0DTFAdc0xBhd6NXGNNHfOkWReqOxFUYBSnCt2gMJebxRPdPd6jeYRHH+ZuCo+U1QXll1nMUopIuSBC870GeU8s3dZOnjRNLLuah2HfPqDxWKsTGc8j3bwJv7667hAf9h6C5ub/lztx92gRrzHCUzNW8fBTFWA+ernAajszTEsivQgReLmHA8mqJAPl0IBxBazCeJelwfnRrwHDOOlyVJDfUa0wnmbCWqqKempyak3Cef32JrCpBrcckMeTOkrB8VPWt0xI0C9Bew7BqrVzAZB8HUBZbOCZjumV1DZToNqEDPzKu2QQvUaPUvarzE0pjK22CVEAGOwd3UnjeI754LAQUv0Rr8YMZFN1jp2WZLAfbHoLaqHmnXXdI5sEeaNcaj+7v3rd0xSRKfJpSt28Lx+pI0OaMvuPTEMxAKPNmCprykG+vro9y74t3entuA0yJ0pwb9C5ojoZxPpzX2YqJcB6yDTKn0V426klBColQuDYEPC/1CYiPifDpXDyYkDOVrGi2qb0Rt7DQNpmj0f9iiKdzdO3K+w4wTvDyXYYHAgdNQ3faDBGUZCXQT6fAEM7Z6lIUzw3By4WktWADkQn9Zrt9flUtDzIiYtDTj6/bI6IwFePcZxBGLMN/jYMdhhF81b8l8doP1co3hBHEy12OjJpOqNwwpEVMrvKdYpNXNM+9iM3HVqhLIVPoyK44ovO7MKV2upXe9YdXU9drnChZvd8NjDaK6oLp/Onvun8VibyUyME4k6Ox6RxB1AnAitApn+6e0rE8WdkJr9xJuOnZbXcD2J4fsHgFj55Mz7sIjgFwPIAffvh7Bub071Tx42mPWT+0BQ0GCT9kpzZ5OGjYFSG5TgGS3ibp+5A9pxiOGs1OGbVcDhmP4gmIeJIVcEi4zSHBm2J4qqwQSQlXe5o+ysKoln3riab8l7ZQ9f1wqmqeYO3PRvMdjyUVhLX98ey7aA1pfDmwx91w8XVn0+91g7gfG48/RD/8e44bPrC347zucxP3vJG06iShu/0jaVN/+HwcvfwM=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 \ No newline at end of file diff --git a/docs/elements/ignite_storage_layout_gpt.drawio b/docs/elements/ignite_storage_layout_gpt.drawio new file mode 100644 index 0000000000000..e681a6f6786e2 --- /dev/null +++ b/docs/elements/ignite_storage_layout_gpt.drawio @@ -0,0 +1,258 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/elements/memory-budget.drawio b/docs/elements/memory-budget.drawio new file mode 100644 index 0000000000000..c8e414dc7aee5 --- /dev/null +++ b/docs/elements/memory-budget.drawio @@ -0,0 +1,1287 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +