diff --git a/umbra/benchmark.sh b/umbra/benchmark.sh index 432bd3ae17..b278e40528 100755 --- a/umbra/benchmark.sh +++ b/umbra/benchmark.sh @@ -1,5 +1,5 @@ #!/bin/bash # Thin shim — actual flow is in lib/benchmark-common.sh. -export BENCH_DOWNLOAD_SCRIPT="download-hits-tsv" +export BENCH_DOWNLOAD_SCRIPT="download-hits-parquet-single" export BENCH_DURABLE=yes exec ../lib/benchmark-common.sh diff --git a/umbra/create.sql b/umbra/create.sql index 2d2cbe4afb..26bde2ea4f 100644 --- a/umbra/create.sql +++ b/umbra/create.sql @@ -103,7 +103,123 @@ create table hits ( hasgclid smallint not null, refererhash bigint not null, urlhash bigint not null, - clid integer not null, - primary key (counterid, eventdate, userid, eventtime, watchid) -); -copy hits from '/data/hits.tsv' with (format text); + clid integer not null +) with (compression=zstd); + +-- Ingest from the Athena parquet rather than the TSV. Umbra's COPY-from- +-- parquet path deadlocks on the second bulk op and the row-group reader had +-- crashes (both worked around / fixed), so we load via the umbra.parquetview +-- table function in a single INSERT — one bulk op, inline type conversion, no +-- staging. The function lives only in the Umbra-mode function table (hence the +-- umbra. qualifier) and surfaces columns CamelCased, so each must be double- +-- quoted. EventTime/ClientEventTime/LocalEventTime are unix-second int64s; +-- EventDate is a uint16 day count from the epoch. Path is the container's +-- '/data' bind mount. +insert into hits +select + "WatchID", + "JavaEnable", + "Title", + "GoodEvent", + to_timestamp("EventTime")::timestamp, + (DATE '1970-01-01' + "EventDate"::int), + "CounterID", + "ClientIP", + "RegionID", + "UserID", + "CounterClass", + "OS", + "UserAgent", + "URL", + "Referer", + "IsRefresh", + "RefererCategoryID", + "RefererRegionID", + "URLCategoryID", + "URLRegionID", + "ResolutionWidth", + "ResolutionHeight", + "ResolutionDepth", + "FlashMajor", + "FlashMinor", + "FlashMinor2", + "NetMajor", + "NetMinor", + "UserAgentMajor", + "UserAgentMinor", + "CookieEnable", + "JavascriptEnable", + "IsMobile", + "MobilePhone", + "MobilePhoneModel", + "Params", + "IPNetworkID", + "TraficSourceID", + "SearchEngineID", + "SearchPhrase", + "AdvEngineID", + "IsArtifical", + "WindowClientWidth", + "WindowClientHeight", + "ClientTimeZone", + to_timestamp("ClientEventTime")::timestamp, + "SilverlightVersion1", + "SilverlightVersion2", + "SilverlightVersion3", + "SilverlightVersion4", + "PageCharset", + "CodeVersion", + "IsLink", + "IsDownload", + "IsNotBounce", + "FUniqID", + "OriginalURL", + "HID", + "IsOldCounter", + "IsEvent", + "IsParameter", + "DontCountHits", + "WithHash", + "HitColor", + to_timestamp("LocalEventTime")::timestamp, + "Age", + "Sex", + "Income", + "Interests", + "Robotness", + "RemoteIP", + "WindowName", + "OpenerName", + "HistoryLength", + "BrowserLanguage", + "BrowserCountry", + "SocialNetwork", + "SocialAction", + "HTTPError", + "SendTiming", + "DNSTiming", + "ConnectTiming", + "ResponseStartTiming", + "ResponseEndTiming", + "FetchTiming", + "SocialSourceNetworkID", + "SocialSourcePage", + "ParamPrice", + "ParamOrderID", + "ParamCurrency", + "ParamCurrencyID", + "OpenstatServiceName", + "OpenstatCampaignID", + "OpenstatAdID", + "OpenstatSourceID", + "UTMSource", + "UTMMedium", + "UTMCampaign", + "UTMContent", + "UTMTerm", + "FromTag", + "HasGCLID", + "RefererHash", + "URLHash", + "CLID" +from umbra.parquetview('/data/hits.parquet'); diff --git a/umbra/load b/umbra/load index f0c1addae2..81152783ed 100755 --- a/umbra/load +++ b/umbra/load @@ -2,7 +2,7 @@ set -eu mkdir -p data -mv hits.tsv data/ +mv hits.parquet data/ chmod -R 777 data # create.sql for umbra both creates the table and ingests via COPY. Use @@ -16,14 +16,14 @@ PGPASSWORD=postgres psql -p 5432 -h 127.0.0.1 -U postgres \ # partial table on memory-constrained hosts (16 GB c6a.4xlarge can't # hold the full mmap working set), letting the benchmark proceed and # producing implausibly fast warm timings on the surviving subset. -# ClickBench's hits dataset is 99,997,497 rows; allow a small margin. +# ClickBench's hits dataset is exactly 99,997,497 rows. expected=99997497 got=$(PGPASSWORD=postgres psql -p 5432 -h 127.0.0.1 -U postgres -tAq \ -c 'SELECT count(*) FROM hits') -if [ "$got" -lt $((expected - 100)) ]; then - echo "umbra/load: hits has $got rows, expected ~$expected — partial load" >&2 +if [ "$got" -ne "$expected" ]; then + echo "umbra/load: hits has $got rows, expected $expected — partial load" >&2 exit 1 fi -rm -f data/hits.tsv +rm -f data/hits.parquet sync diff --git a/umbra/results/20260619/c6a.4xlarge.json b/umbra/results/20260619/c6a.4xlarge.json new file mode 100644 index 0000000000..7b32eb328a --- /dev/null +++ b/umbra/results/20260619/c6a.4xlarge.json @@ -0,0 +1,235 @@ +{ + "system": "Umbra", + "date": "2026-06-19", + "machine": "c6a.4xlarge", + "cluster_size": 1, + "proprietary": "yes", + "hardware": "cpu", + "tuned": "no", + "tags": [ + "C++", + "column-oriented", + "PostgreSQL compatible" + ], + "load_time": 118.635, + "data_size": 9642782263, + "concurrent_qps": 7.443, + "concurrent_error_ratio": 0.325, + "result": [ + [ + 0.149, + 0.008, + 0.008 + ], + [ + 0.22, + 0.004, + 0.004 + ], + [ + 0.221, + 0.027, + 0.026 + ], + [ + 0.296, + 0.028, + 0.027 + ], + [ + 0.348, + 0.134, + 0.134 + ], + [ + 0.498, + 0.171, + 0.171 + ], + [ + 0.194, + 0.024, + 0.025 + ], + [ + 0.244, + 0.005, + 0.005 + ], + [ + 0.46, + 0.161, + 0.16 + ], + [ + 0.603, + 0.231, + 0.227 + ], + [ + 0.392, + 0.026, + 0.026 + ], + [ + 0.271, + 0.028, + 0.028 + ], + [ + 0.523, + 0.161, + 0.16 + ], + [ + 1.144, + 0.306, + 0.307 + ], + [ + 0.547, + 0.179, + 0.178 + ], + [ + 0.393, + 0.169, + 0.171 + ], + [ + 1.055, + 0.361, + 0.362 + ], + [ + 0.973, + 0.222, + 0.222 + ], + [ + 3.378, + 0.866, + 0.829 + ], + [ + 0.348, + 0.002, + 0.002 + ], + [ + 4.185, + 0.273, + 0.273 + ], + [ + 5.07, + 0.082, + 0.081 + ], + [ + 9.086, + 0.147, + 0.147 + ], + [ + 1.833, + 0.011, + 0.011 + ], + [ + 0.236, + 0.018, + 0.006 + ], + [ + 0.256, + 0.01, + 0.01 + ], + [ + 0.248, + 0.006, + 0.006 + ], + [ + 4.202, + 0.287, + 0.289 + ], + [ + 4.2, + 1.51, + 1.503 + ], + [ + 0.167, + 0.028, + 0.03 + ], + [ + 0.785, + 0.083, + 0.083 + ], + [ + 3.813, + 0.131, + 0.129 + ], + [ + 3.974, + 1.315, + 1.314 + ], + [ + 4.468, + 0.926, + 0.779 + ], + [ + 4.462, + 0.863, + 0.779 + ], + [ + 0.299, + 0.127, + 0.124 + ], + [ + 0.252, + 0.01, + 0.011 + ], + [ + 0.233, + 0.006, + 0.006 + ], + [ + 0.27, + 0.003, + 0.003 + ], + [ + 0.306, + 0.026, + 0.022 + ], + [ + 0.224, + 0.004, + 0.003 + ], + [ + 0.212, + 0.003, + 0.003 + ], + [ + 0.217, + 0.004, + 0.004 + ] + ] +} diff --git a/umbra/results/20260619/c6a.metal.json b/umbra/results/20260619/c6a.metal.json new file mode 100644 index 0000000000..66a9f0d381 --- /dev/null +++ b/umbra/results/20260619/c6a.metal.json @@ -0,0 +1,235 @@ +{ + "system": "Umbra", + "date": "2026-06-19", + "machine": "c6a.metal", + "cluster_size": 1, + "proprietary": "yes", + "hardware": "cpu", + "tuned": "no", + "tags": [ + "C++", + "column-oriented", + "PostgreSQL compatible" + ], + "load_time": 42.112, + "data_size": 9929244880, + "concurrent_qps": 15.512, + "concurrent_error_ratio": 0.098, + "result": [ + [ + 0.052, + 0.003, + 0.003 + ], + [ + 0.183, + 0.003, + 0.003 + ], + [ + 0.195, + 0.009, + 0.01 + ], + [ + 0.294, + 0.011, + 0.009 + ], + [ + 0.388, + 0.069, + 0.067 + ], + [ + 0.413, + 0.068, + 0.069 + ], + [ + 0.167, + 0.011, + 0.009 + ], + [ + 0.233, + 0.004, + 0.004 + ], + [ + 0.547, + 0.08, + 0.08 + ], + [ + 0.542, + 0.118, + 0.119 + ], + [ + 0.307, + 0.019, + 0.02 + ], + [ + 0.318, + 0.017, + 0.017 + ], + [ + 0.324, + 0.064, + 0.063 + ], + [ + 1.146, + 0.113, + 0.113 + ], + [ + 0.402, + 0.081, + 0.067 + ], + [ + 0.477, + 0.098, + 0.097 + ], + [ + 1.141, + 0.139, + 0.139 + ], + [ + 1.123, + 0.051, + 0.05 + ], + [ + 3.251, + 0.379, + 0.35 + ], + [ + 0.306, + 0.003, + 0.002 + ], + [ + 4.435, + 0.061, + 0.059 + ], + [ + 5.323, + 0.026, + 0.027 + ], + [ + 9.721, + 0.041, + 0.044 + ], + [ + 2.492, + 0.042, + 0.082 + ], + [ + 0.205, + 0.005, + 0.005 + ], + [ + 0.371, + null, + null + ], + [ + 0.233, + 0.006, + 0.005 + ], + [ + 4.365, + 0.068, + 0.07 + ], + [ + 4.292, + 0.334, + 0.342 + ], + [ + 0.068, + 0.014, + 0.013 + ], + [ + 0.76, + 0.037, + 0.037 + ], + [ + 3.792, + 0.053, + 0.053 + ], + [ + 3.344, + 0.538, + 0.535 + ], + [ + 4.522, + 0.372, + 0.317 + ], + [ + 4.513, + 0.369, + 0.309 + ], + [ + 0.331, + 0.068, + 0.067 + ], + [ + 0.151, + 0.011, + 0.012 + ], + [ + 0.137, + 0.006, + 0.006 + ], + [ + 0.174, + 0.009, + 0.005 + ], + [ + 0.338, + 0.016, + 0.015 + ], + [ + 0.114, + 0.01, + 0.009 + ], + [ + 0.108, + 0.006, + 0.005 + ], + [ + 0.13, + 0.01, + 0.009 + ] + ] +} diff --git a/umbra/results/20260619/c7a.metal-48xl.json b/umbra/results/20260619/c7a.metal-48xl.json new file mode 100644 index 0000000000..892e77b195 --- /dev/null +++ b/umbra/results/20260619/c7a.metal-48xl.json @@ -0,0 +1,235 @@ +{ + "system": "Umbra", + "date": "2026-06-19", + "machine": "c7a.metal-48xl", + "cluster_size": 1, + "proprietary": "yes", + "hardware": "cpu", + "tuned": "no", + "tags": [ + "C++", + "column-oriented", + "PostgreSQL compatible" + ], + "load_time": 40.795, + "data_size": 9903048592, + "concurrent_qps": 28.213, + "concurrent_error_ratio": 0.132, + "result": [ + [ + 0.066, + 0.003, + 0.003 + ], + [ + 0.275, + 0.002, + 0.002 + ], + [ + 0.295, + 0.01, + 0.009 + ], + [ + 0.383, + 0.01, + 0.008 + ], + [ + 0.488, + 0.025, + 0.025 + ], + [ + 0.49, + 0.039, + 0.039 + ], + [ + 0.264, + 0.009, + 0.009 + ], + [ + 0.285, + 0.003, + 0.003 + ], + [ + 0.582, + 0.033, + 0.033 + ], + [ + 0.612, + 0.044, + 0.042 + ], + [ + 0.475, + 0.014, + 0.014 + ], + [ + 0.449, + 0.013, + 0.013 + ], + [ + 0.432, + 0.045, + 0.044 + ], + [ + 1.186, + 0.067, + 0.064 + ], + [ + 0.454, + 0.049, + 0.047 + ], + [ + 0.477, + 0.039, + 0.036 + ], + [ + 1.2, + 0.064, + 0.062 + ], + [ + 1.207, + 0.04, + 0.04 + ], + [ + 3.198, + 0.124, + 0.121 + ], + [ + 0.394, + 0.002, + 0.002 + ], + [ + 4.541, + 0.04, + 0.04 + ], + [ + 5.432, + 0.014, + 0.015 + ], + [ + 9.762, + 0.023, + 0.021 + ], + [ + 3.27, + 0.011, + 0.011 + ], + [ + 0.439, + 0.003, + 0.003 + ], + [ + 0.432, + 0.004, + 0.004 + ], + [ + 0.47, + 0.003, + 0.003 + ], + [ + 4.588, + 0.045, + 0.046 + ], + [ + 4.486, + 0.216, + 0.21 + ], + [ + 0.337, + 0.011, + 0.011 + ], + [ + 0.977, + 0.032, + 0.029 + ], + [ + 3.99, + 0.03, + 0.03 + ], + [ + 3.287, + 0.182, + 0.18 + ], + [ + 4.647, + 0.173, + 0.165 + ], + [ + 4.638, + 0.176, + 0.167 + ], + [ + 0.423, + 0.029, + 0.03 + ], + [ + 0.392, + 0.011, + 0.011 + ], + [ + 0.178, + 0.009, + 0.009 + ], + [ + 0.196, + 0.004, + 0.007 + ], + [ + 0.537, + 0.014, + 0.015 + ], + [ + 0.181, + 0.009, + 0.009 + ], + [ + 0.151, + 0.004, + 0.004 + ], + [ + 0.143, + 0.01, + 0.01 + ] + ] +} diff --git a/umbra/results/20260619/c8g.4xlarge.json b/umbra/results/20260619/c8g.4xlarge.json new file mode 100644 index 0000000000..e24d75d579 --- /dev/null +++ b/umbra/results/20260619/c8g.4xlarge.json @@ -0,0 +1,235 @@ +{ + "system": "Umbra", + "date": "2026-06-19", + "machine": "c8g.4xlarge", + "cluster_size": 1, + "proprietary": "yes", + "hardware": "cpu", + "tuned": "no", + "tags": [ + "C++", + "column-oriented", + "PostgreSQL compatible" + ], + "load_time": 106.836, + "data_size": 9644778608, + "concurrent_qps": 3.655, + "concurrent_error_ratio": 0.283, + "result": [ + [ + 0.125, + 0.012, + 0.012 + ], + [ + 0.137, + 0.003, + 0.003 + ], + [ + 0.151, + 0.022, + 0.022 + ], + [ + 0.28, + 0.024, + 0.024 + ], + [ + 0.272, + 0.064, + 0.064 + ], + [ + 0.332, + 0.097, + 0.097 + ], + [ + 0.136, + 0.016, + 0.016 + ], + [ + 0.149, + 0.004, + 0.004 + ], + [ + 0.365, + 0.074, + 0.077 + ], + [ + 0.501, + 0.109, + 0.109 + ], + [ + 0.29, + 0.013, + 0.013 + ], + [ + 0.321, + 0.014, + 0.014 + ], + [ + 0.317, + 0.083, + 0.084 + ], + [ + 0.955, + 0.149, + 0.151 + ], + [ + 0.383, + 0.087, + 0.087 + ], + [ + 0.307, + 0.075, + 0.074 + ], + [ + 0.89, + 0.161, + 0.16 + ], + [ + 0.869, + 0.113, + 0.113 + ], + [ + 2.935, + 0.315, + 0.316 + ], + [ + 0.239, + 0.001, + 0.001 + ], + [ + 4.14, + 0.427, + 0.425 + ], + [ + 4.984, + 0.068, + 0.071 + ], + [ + 9.048, + 0.108, + 0.1 + ], + [ + 1.851, + 0.019, + 0.019 + ], + [ + 0.228, + 0.003, + 0.003 + ], + [ + 0.257, + 0.006, + 0.006 + ], + [ + 0.255, + 0.003, + 0.003 + ], + [ + 4.159, + 0.223, + 0.223 + ], + [ + 4.109, + 0.859, + 0.847 + ], + [ + 0.141, + 0.026, + 0.026 + ], + [ + 0.699, + 0.035, + 0.035 + ], + [ + 3.704, + 0.046, + 0.046 + ], + [ + 3.248, + 0.475, + 0.48 + ], + [ + 4.256, + 0.377, + 0.348 + ], + [ + 4.256, + 0.371, + 0.383 + ], + [ + 0.274, + 0.064, + 0.064 + ], + [ + 0.193, + 0.007, + 0.007 + ], + [ + 0.179, + 0.004, + 0.004 + ], + [ + 0.203, + 0.003, + 0.003 + ], + [ + 0.239, + 0.012, + 0.012 + ], + [ + 0.185, + 0.003, + 0.003 + ], + [ + 0.165, + 0.003, + 0.003 + ], + [ + 0.164, + 0.005, + 0.005 + ] + ] +} diff --git a/umbra/results/20260619/c8g.metal-48xl.json b/umbra/results/20260619/c8g.metal-48xl.json new file mode 100644 index 0000000000..abcc4856ee --- /dev/null +++ b/umbra/results/20260619/c8g.metal-48xl.json @@ -0,0 +1,235 @@ +{ + "system": "Umbra", + "date": "2026-06-19", + "machine": "c8g.metal-48xl", + "cluster_size": 1, + "proprietary": "yes", + "hardware": "cpu", + "tuned": "no", + "tags": [ + "C++", + "column-oriented", + "PostgreSQL compatible" + ], + "load_time": 39.797, + "data_size": 9874885928, + "concurrent_qps": 30.252, + "concurrent_error_ratio": 0.223, + "result": [ + [ + 0.044, + 0.004, + 0.003 + ], + [ + 0.132, + 0.001, + 0.001 + ], + [ + 0.119, + 0.005, + 0.005 + ], + [ + 0.242, + 0.006, + 0.006 + ], + [ + 0.255, + 0.021, + 0.024 + ], + [ + 0.273, + 0.039, + 0.038 + ], + [ + 0.101, + 0.004, + 0.004 + ], + [ + 0.114, + 0.003, + 0.003 + ], + [ + 0.834, + 0.035, + 0.033 + ], + [ + 0.474, + 0.056, + 0.056 + ], + [ + 0.27, + 0.017, + 0.016 + ], + [ + 0.251, + 0.018, + 0.018 + ], + [ + 0.236, + 0.035, + 0.037 + ], + [ + 1.073, + 0.076, + 0.061 + ], + [ + 0.266, + 0.038, + 0.038 + ], + [ + 0.294, + 0.029, + 0.029 + ], + [ + 1.027, + 0.059, + 0.059 + ], + [ + 1.462, + 0.05, + 0.03 + ], + [ + 3.043, + 0.123, + 0.115 + ], + [ + 0.205, + 0.001, + 0.001 + ], + [ + 4.399, + 0.083, + 0.084 + ], + [ + 5.269, + 0.018, + 0.018 + ], + [ + 9.576, + 0.032, + 0.029 + ], + [ + 2.706, + 0.006, + 0.006 + ], + [ + 0.254, + 0.002, + 0.002 + ], + [ + 0.297, + 0.003, + 0.002 + ], + [ + 0.277, + 0.002, + 0.002 + ], + [ + 4.417, + 0.054, + 0.055 + ], + [ + 4.29, + 0.165, + 0.164 + ], + [ + 0.114, + 0.008, + 0.008 + ], + [ + 0.868, + 0.016, + 0.016 + ], + [ + 3.844, + 0.02, + 0.02 + ], + [ + 3.131, + 0.172, + 0.175 + ], + [ + 4.462, + 0.177, + 0.169 + ], + [ + 4.448, + 0.169, + 0.16 + ], + [ + 0.217, + 0.024, + 0.024 + ], + [ + 0.179, + 0.01, + 0.009 + ], + [ + 0.174, + 0.007, + 0.006 + ], + [ + 0.175, + 0.006, + 0.005 + ], + [ + 0.433, + 0.014, + 0.014 + ], + [ + 0.156, + 0.007, + 0.007 + ], + [ + 0.146, + 0.005, + 0.005 + ], + [ + 0.148, + 0.012, + 0.009 + ] + ] +} diff --git a/umbra/start b/umbra/start index 097802346f..de497b7778 100755 --- a/umbra/start +++ b/umbra/start @@ -8,68 +8,12 @@ fi sudo docker stop umbradb >/dev/null 2>&1 || true sudo docker rm umbradb >/dev/null 2>&1 || true -# Umbra's working set during the ClickBench COPY blows well past the -# guest VM's 16 GiB RAM. The agent has already mkswap'd + swapon'd a -# 256 GiB swap.raw block device, so what we need is: -# - vm.overcommit_memory=1 so the kernel doesn't refuse a single -# huge mmap (default heuristic mode rejects allocations that -# would exceed physical RAM + swap by a wide margin). -# - vm.swappiness=100 to bias the kernel toward paging anonymous -# memory out as soon as we exceed physical RAM (default 60 is -# too conservative — Umbra ENOMEMs before the kernel reclaims -# enough). -# - vm.max_map_count raised. Umbra issues a large number of small -# mmaps; the 65530 default is easy to hit on a 100 M-row COPY. -# - NO docker memory cgroup. cgroup v2 silently discards -# --memory-swappiness, and any --memory cap creates a hard -# ceiling that the kernel will OOM on regardless of how much -# swap is available. Let the host kernel manage memory. -sudo sysctl -wq vm.overcommit_memory=1 vm.swappiness=100 \ - vm.max_map_count=1048576 || true - sudo docker run -d --name umbradb \ -v "$(pwd)/db:/var/db" \ -v "$(pwd)/data:/data" \ -p 5432:5432 \ + --privileged \ --ulimit nofile=1048576:1048576 \ --ulimit memlock=-1:-1 \ + -e ASYNCIO=0 \ umbradb/umbra:latest >/dev/null - -# Container needs a moment before psql can connect. -for _ in $(seq 1 60); do - if PGPASSWORD=postgres psql -p 5432 -h 127.0.0.1 -U postgres \ - -c 'SELECT 1' >/dev/null 2>&1; then - # Diagnostic dump so a future OOM during load lands with the - # memory/swap state of the VM in the provision log. Previously - # silent — every "unable to allocate memory" failure looked - # the same and we couldn't tell whether the agent's mkswap+ - # swapon ran, whether the container saw the swap, or whether - # the sysctl tweaks above stuck. - echo "=== umbra: VM memory state ===" - free -h || true - echo "=== umbra: swap state ===" - swapon --show=NAME,SIZE,USED,PRIO --bytes || true - echo "=== umbra: sysctl ===" - for k in vm.overcommit_memory vm.swappiness vm.max_map_count \ - vm.overcommit_ratio; do - echo " $k = $(sysctl -n $k 2>/dev/null)" - done - echo "=== umbra: container memory cgroup ===" - sudo docker inspect umbradb --format \ - 'memory={{.HostConfig.Memory}} memory-swap={{.HostConfig.MemorySwap}}' || true - echo "=== umbra: container memlock ulimit ===" - sudo docker exec umbradb sh -c 'ulimit -l' 2>&1 || true - cgpath=$(sudo docker inspect umbradb --format '{{.State.Pid}}' 2>/dev/null | \ - xargs -I{} cat /proc/{}/cgroup 2>/dev/null | awk -F: '{print $NF}') - if [ -n "$cgpath" ]; then - for f in memory.max memory.swap.max memory.swap.current; do - p="/sys/fs/cgroup${cgpath}/$f" - [ -r "$p" ] && echo " $f = $(cat "$p")" - done - fi - echo "=== umbra: container procs ===" - sudo docker top umbradb -eo pid,vsz,rss,comm 2>&1 | head -10 - exit 0 - fi - sleep 1 -done