A high-throughput and memory-efficient inference and serving engine for LLMs
Mirrored from https://github.com/tduncan-lum/Nvidia-Optimization-Stack---VLLM.git
Synced Nov 17, 03:00 UTC
Usage Stats Collection (#2852)
yhu422 committed
Mar 28, 2024 at 22:16 UTC
d8658c8cc16d67e6690cb0f3f340e365652ce80b
15 files changed
+362
-24
.buildkite/test-template.j2
+2
@@ -53,6 +53,8 @@ steps:
53
nvidia.com/gpu: "{{ step.num_gpus or default_num_gpu }}"
54
{% endif %}
55
env:
56
+ - name: VLLM_USAGE_SOURCE
57
+ value: ci-test
58
- name: HF_TOKEN
59
valueFrom:
60
secretKeyRef:
Dockerfile
+2
@@ -132,5 +132,7 @@ RUN --mount=type=cache,target=/root/.cache/pip \
132
COPY --from=build /workspace/vllm/*.so /workspace/vllm/
133
COPY vllm vllm
134
135
+ENV VLLM_USAGE_SOURCE production-docker-image
136
+
137
ENTRYPOINT ["python3", "-m", "vllm.entrypoints.openai.api_server"]
138
#################### OPENAI API SERVER ####################
docs/source/index.rst
+1
@@ -73,6 +73,7 @@ Documentation
73
serving/deploying_with_docker
74
serving/distributed_serving
75
serving/metrics
76
+ serving/usage_stats
77
serving/integrations
78
79
.. toctree::
docs/source/serving/usage_stats.md
new
+57
@@ -0,0 +1,57 @@
1
+# Usage Stats Collection
2
+
3
+vLLM collects anonymous usage data by default to help the engineering team better understand which hardware and model configurations are widely used. This data allows them to prioritize their efforts on the most common workloads. The collected data is transparent, does not contain any sensitive information, and will be publicly released for the community's benefit.
4
+
5
+## What data is collected?
6
+
7
+You can see the up to date list of data collected by vLLM in the [usage_lib.py](https://github.com/vllm-project/vllm/blob/main/vllm/usage/usage_lib.py).
8
+
9
+Here is an example as of v0.4.0:
10
+
11
+```json
12
+{
13
+ "uuid": "fbe880e9-084d-4cab-a395-8984c50f1109",
14
+ "provider": "GCP",
15
+ "num_cpu": 24,
16
+ "cpu_type": "Intel(R) Xeon(R) CPU @ 2.20GHz",
17
+ "cpu_family_model_stepping": "6,85,7",
18
+ "total_memory": 101261135872,
19
+ "architecture": "x86_64",
20
+ "platform": "Linux-5.10.0-28-cloud-amd64-x86_64-with-glibc2.31",
21
+ "gpu_count": 2,
22
+ "gpu_type": "NVIDIA L4",
23
+ "gpu_memory_per_device": 23580639232,
24
+ "model_architecture": "OPTForCausalLM",
25
+ "vllm_version": "0.3.2+cu123",
26
+ "context": "LLM_CLASS",
27
+ "log_time": 1711663373492490000,
28
+ "source": "production",
29
+ "dtype": "torch.float16",
30
+ "tensor_parallel_size": 1,
31
+ "block_size": 16,
32
+ "gpu_memory_utilization": 0.9,
33
+ "quantization": null,
34
+ "kv_cache_dtype": "auto",
35
+ "enable_lora": false,
36
+ "enable_prefix_caching": false,
37
+ "enforce_eager": false,
38
+ "disable_custom_all_reduce": true
39
+}
40
+```
41
+
42
+You can preview the collected data by running the following command:
43
+
44
+```bash
45
+tail ~/.config/vllm/usage_stats.json
46
+```
47
+
48
+## Opt-out of Usage Stats Collection
49
+
50
+You can opt-out of usage stats collection by setting the VLLM_NO_USAGE_STATS or DO_NOT_TRACK environment variable, or by creating a ~/.config/vllm/do_not_track file:
51
+
52
+```bash
53
+# Any of the following methods can disable usage stats collection
54
+export VLLM_NO_USAGE_STATS=1
55
+export DO_NOT_TRACK=1
56
+mkdir -p ~/.config/vllm && touch ~/.config/vllm/do_not_track
57
+```
requirements-neuron.txt
+3
@@ -7,3 +7,6 @@ fastapi
7
uvicorn[standard]
8
pydantic >= 2.0 # Required for OpenAI server.
9
prometheus_client >= 0.18.0
10
+requests
11
+psutil
12
+py-cpuinfo
\ No newline at end of file
requirements-rocm.txt
+2
@@ -2,6 +2,8 @@ cmake>=3.21
2
ninja # For faster builds.
3
typing-extensions>=4.8.0
4
starlette
5
+requests
6
+py-cpuinfo
7
psutil
8
ray >= 2.9
9
sentencepiece # Required for LLaMA tokenizer.
requirements.txt
+3
@@ -5,6 +5,9 @@ ray >= 2.9
5
sentencepiece # Required for LLaMA tokenizer.
6
numpy
7
torch == 2.1.2
8
+requests
9
+psutil
10
+py-cpuinfo
11
transformers >= 4.39.1 # Required for StarCoder2 & Llava.
12
xformers == 0.0.23.post1 # Required for CUDA 12.1.
13
fastapi
vllm/engine/async_llm_engine.py
+18
-11
@@ -16,6 +16,7 @@ from vllm.lora.request import LoRARequest
16
from vllm.outputs import RequestOutput
17
from vllm.sampling_params import SamplingParams
18
from vllm.sequence import MultiModalData
19
+from vllm.usage.usage_lib import UsageContext
20
21
logger = init_logger(__name__)
22
ENGINE_ITERATION_TIMEOUT_S = int(
@@ -319,9 +320,12 @@ class AsyncLLMEngine:
320
self._errored_with: Optional[BaseException] = None
321
322
@classmethod
322
- def from_engine_args(cls,
323
- engine_args: AsyncEngineArgs,
324
- start_engine_loop: bool = True) -> "AsyncLLMEngine":
323
+ def from_engine_args(
324
+ cls,
325
+ engine_args: AsyncEngineArgs,
326
+ start_engine_loop: bool = True,
327
+ usage_context: UsageContext = UsageContext.ENGINE_CONTEXT,
328
+ ) -> "AsyncLLMEngine":
329
"""Creates an async LLM engine from the engine arguments."""
330
# Create the engine configs.
331
engine_configs = engine_args.create_engine_configs()
@@ -341,14 +345,17 @@ class AsyncLLMEngine:
345
from vllm.executor.gpu_executor import GPUExecutorAsync
346
executor_class = GPUExecutorAsync
347
# Create the async LLM engine.
344
- engine = cls(parallel_config.worker_use_ray,
345
- engine_args.engine_use_ray,
346
- *engine_configs,
347
- executor_class,
348
- log_requests=not engine_args.disable_log_requests,
349
- log_stats=not engine_args.disable_log_stats,
350
- max_log_len=engine_args.max_log_len,
351
- start_engine_loop=start_engine_loop)
348
+ engine = cls(
349
+ parallel_config.worker_use_ray,
350
+ engine_args.engine_use_ray,
351
+ *engine_configs,
352
+ executor_class,
353
+ log_requests=not engine_args.disable_log_requests,
354
+ log_stats=not engine_args.disable_log_stats,
355
+ max_log_len=engine_args.max_log_len,
356
+ start_engine_loop=start_engine_loop,
357
+ usage_context=usage_context,
358
+ )
359
return engine
360
361
@property
vllm/engine/llm_engine.py
+49
-4
@@ -13,6 +13,7 @@ from vllm.engine.ray_utils import initialize_ray_cluster
13
from vllm.executor.executor_base import ExecutorBase
14
from vllm.logger import init_logger
15
from vllm.lora.request import LoRARequest
16
+from vllm.model_executor.model_loader import get_architecture_class_name
17
from vllm.outputs import RequestOutput
18
from vllm.sampling_params import SamplingParams
19
from vllm.sequence import (MultiModalData, SamplerOutput, Sequence,
@@ -21,6 +22,8 @@ from vllm.sequence import (MultiModalData, SamplerOutput, Sequence,
22
from vllm.transformers_utils.detokenizer import Detokenizer
23
from vllm.transformers_utils.tokenizer_group import (BaseTokenizerGroup,
24
get_tokenizer_group)
25
+from vllm.usage.usage_lib import (UsageContext, is_usage_stats_enabled,
26
+ usage_message)
27
from vllm.utils import Counter
28
29
logger = init_logger(__name__)
@@ -53,6 +56,7 @@ class LLMEngine:
56
executor_class: The model executor class for managing distributed
57
execution.
58
log_stats: Whether to log statistics.
59
+ usage_context: Specified entry point, used for usage info collection
60
"""
61
62
def __init__(
@@ -66,6 +70,7 @@ class LLMEngine:
70
vision_language_config: Optional["VisionLanguageConfig"],
71
executor_class: Type[ExecutorBase],
72
log_stats: bool,
73
+ usage_context: UsageContext = UsageContext.ENGINE_CONTEXT,
74
) -> None:
75
logger.info(
76
f"Initializing an LLM engine (v{vllm.__version__}) with config: "
@@ -108,6 +113,39 @@ class LLMEngine:
113
device_config, lora_config,
114
vision_language_config)
115
116
+ # If usage stat is enabled, collect relevant info.
117
+ if is_usage_stats_enabled():
118
+ usage_message.report_usage(
119
+ get_architecture_class_name(model_config),
120
+ usage_context,
121
+ extra_kvs={
122
+ # Common configuration
123
+ "dtype":
124
+ str(model_config.dtype),
125
+ "tensor_parallel_size":
126
+ parallel_config.tensor_parallel_size,
127
+ "block_size":
128
+ cache_config.block_size,
129
+ "gpu_memory_utilization":
130
+ cache_config.gpu_memory_utilization,
131
+
132
+ # Quantization
133
+ "quantization":
134
+ model_config.quantization,
135
+ "kv_cache_dtype":
136
+ cache_config.cache_dtype,
137
+
138
+ # Feature flags
139
+ "enable_lora":
140
+ bool(lora_config),
141
+ "enable_prefix_caching":
142
+ cache_config.enable_prefix_caching,
143
+ "enforce_eager":
144
+ model_config.enforce_eager,
145
+ "disable_custom_all_reduce":
146
+ parallel_config.disable_custom_all_reduce,
147
+ })
148
+
149
# Ping the tokenizer to ensure liveness if it runs in a
150
# different process.
151
self.tokenizer.ping()
@@ -125,7 +163,11 @@ class LLMEngine:
163
self.stat_logger.info("cache_config", self.cache_config)
164
165
@classmethod
128
- def from_engine_args(cls, engine_args: EngineArgs) -> "LLMEngine":
166
+ def from_engine_args(
167
+ cls,
168
+ engine_args: EngineArgs,
169
+ usage_context: UsageContext = UsageContext.ENGINE_CONTEXT,
170
+ ) -> "LLMEngine":
171
"""Creates an LLM engine from the engine arguments."""
172
# Create the engine configs.
173
engine_configs = engine_args.create_engine_configs()
@@ -147,9 +189,12 @@ class LLMEngine:
189
executor_class = GPUExecutor
190
191
# Create the LLM engine.
150
- engine = cls(*engine_configs,
151
- executor_class=executor_class,
152
- log_stats=not engine_args.disable_log_stats)
192
+ engine = cls(
193
+ *engine_configs,
194
+ executor_class=executor_class,
195
+ log_stats=not engine_args.disable_log_stats,
196
+ usage_context=usage_context,
197
+ )
198
return engine
199
200
def __reduce__(self):
vllm/entrypoints/api_server.py
+3
-2
@@ -18,6 +18,7 @@ from fastapi.responses import JSONResponse, Response, StreamingResponse
18
from vllm.engine.arg_utils import AsyncEngineArgs
19
from vllm.engine.async_llm_engine import AsyncLLMEngine
20
from vllm.sampling_params import SamplingParams
21
+from vllm.usage.usage_lib import UsageContext
22
from vllm.utils import random_uuid
23
24
TIMEOUT_KEEP_ALIVE = 5 # seconds.
@@ -100,9 +101,9 @@ if __name__ == "__main__":
101
help="FastAPI root_path when app is behind a path based routing proxy")
102
parser = AsyncEngineArgs.add_cli_args(parser)
103
args = parser.parse_args()
103
-
104
engine_args = AsyncEngineArgs.from_cli_args(args)
105
- engine = AsyncLLMEngine.from_engine_args(engine_args)
105
+ engine = AsyncLLMEngine.from_engine_args(
106
+ engine_args, usage_context=UsageContext.API_SERVER)
107
108
app.root_path = args.root_path
109
uvicorn.run(app,
vllm/entrypoints/llm.py
+3
-1
@@ -10,6 +10,7 @@ from vllm.lora.request import LoRARequest
10
from vllm.outputs import RequestOutput
11
from vllm.sampling_params import SamplingParams
12
from vllm.sequence import MultiModalData
13
+from vllm.usage.usage_lib import UsageContext
14
from vllm.utils import Counter
15
16
@@ -108,7 +109,8 @@ class LLM:
109
disable_custom_all_reduce=disable_custom_all_reduce,
110
**kwargs,
111
)
111
- self.llm_engine = LLMEngine.from_engine_args(engine_args)
112
+ self.llm_engine = LLMEngine.from_engine_args(
113
+ engine_args, usage_context=UsageContext.LLM_CLASS)
114
self.request_counter = Counter()
115
116
def get_tokenizer(
vllm/entrypoints/openai/api_server.py
+3
-2
@@ -22,6 +22,7 @@ from vllm.entrypoints.openai.protocol import (ChatCompletionRequest,
22
from vllm.entrypoints.openai.serving_chat import OpenAIServingChat
23
from vllm.entrypoints.openai.serving_completion import OpenAIServingCompletion
24
from vllm.logger import init_logger
25
+from vllm.usage.usage_lib import UsageContext
26
27
TIMEOUT_KEEP_ALIVE = 5 # seconds
28
@@ -151,9 +152,9 @@ if __name__ == "__main__":
152
served_model = args.served_model_name
153
else:
154
served_model = args.model
154
-
155
engine_args = AsyncEngineArgs.from_cli_args(args)
156
- engine = AsyncLLMEngine.from_engine_args(engine_args)
156
+ engine = AsyncLLMEngine.from_engine_args(
157
+ engine_args, usage_context=UsageContext.OPENAI_API_SERVER)
158
openai_serving_chat = OpenAIServingChat(engine, served_model,
159
args.response_role,
160
args.lora_modules,
vllm/model_executor/model_loader.py
+9
-4
@@ -1,6 +1,6 @@
1
"""Utilities for selecting and loading models."""
2
import contextlib
3
-from typing import Type
3
+from typing import Tuple, Type
4
5
import torch
6
import torch.nn as nn
@@ -25,7 +25,8 @@ def _set_default_torch_dtype(dtype: torch.dtype):
25
torch.set_default_dtype(old_dtype)
26
27
28
-def _get_model_architecture(model_config: ModelConfig) -> Type[nn.Module]:
28
+def _get_model_architecture(
29
+ model_config: ModelConfig) -> Tuple[Type[nn.Module], str]:
30
architectures = getattr(model_config.hf_config, "architectures", [])
31
# Special handling for quantized Mixtral.
32
# FIXME(woosuk): This is a temporary hack.
@@ -36,17 +37,21 @@ def _get_model_architecture(model_config: ModelConfig) -> Type[nn.Module]:
37
for arch in architectures:
38
model_cls = ModelRegistry.load_model_cls(arch)
39
if model_cls is not None:
39
- return model_cls
40
+ return (model_cls, arch)
41
raise ValueError(
42
f"Model architectures {architectures} are not supported for now. "
43
f"Supported architectures: {ModelRegistry.get_supported_archs()}")
44
45
46
+def get_architecture_class_name(model_config: ModelConfig) -> str:
47
+ return _get_model_architecture(model_config)[1]
48
+
49
+
50
def get_model(model_config: ModelConfig, device_config: DeviceConfig,
51
**kwargs) -> nn.Module:
52
lora_config = kwargs.get("lora_config", None)
53
vision_language_config = kwargs.get("vision_language_config", None)
49
- model_class = _get_model_architecture(model_config)
54
+ model_class = _get_model_architecture(model_config)[0]
55
56
# Get the (maybe quantized) linear method.
57
linear_method = None
vllm/usage/__init__.py
vllm/usage/usage_lib.py
new
+207
@@ -0,0 +1,207 @@
1
+import datetime
2
+import json
3
+import logging
4
+import os
5
+import platform
6
+import time
7
+from enum import Enum
8
+from pathlib import Path
9
+from threading import Thread
10
+from typing import Dict, Optional
11
+from uuid import uuid4
12
+
13
+import cpuinfo
14
+import pkg_resources
15
+import psutil
16
+import requests
17
+import torch
18
+
19
+_config_home = os.getenv("XDG_CONFIG_HOME", os.path.expanduser("~/.config"))
20
+_USAGE_STATS_JSON_PATH = os.path.join(_config_home, "vllm/usage_stats.json")
21
+_USAGE_STATS_DO_NOT_TRACK_PATH = os.path.join(_config_home,
22
+ "vllm/do_not_track")
23
+_USAGE_STATS_ENABLED = None
24
+_USAGE_STATS_SERVER = os.environ.get("VLLM_USAGE_STATS_SERVER",
25
+ "https://stats.vllm.ai")
26
+
27
+
28
+def is_usage_stats_enabled():
29
+ """Determine whether or not we can send usage stats to the server.
30
+ The logic is as follows:
31
+ - By default, it should be enabled.
32
+ - Two environment variables can disable it:
33
+ - DO_NOT_TRACK=1
34
+ - VLLM_NO_USAGE_STATS=1
35
+ - A file in the home directory can disable it if it exists:
36
+ - $HOME/.config/vllm/do_not_track
37
+ """
38
+ global _USAGE_STATS_ENABLED
39
+ if _USAGE_STATS_ENABLED is None:
40
+ do_not_track = os.environ.get("DO_NOT_TRACK", "0") == "1"
41
+ no_usage_stats = os.environ.get("VLLM_NO_USAGE_STATS", "0") == "1"
42
+ do_not_track_file = os.path.exists(_USAGE_STATS_DO_NOT_TRACK_PATH)
43
+
44
+ _USAGE_STATS_ENABLED = not (do_not_track or no_usage_stats
45
+ or do_not_track_file)
46
+ return _USAGE_STATS_ENABLED
47
+
48
+
49
+def _get_current_timestamp_ns() -> int:
50
+ return int(datetime.datetime.now(datetime.timezone.utc).timestamp() * 1e9)
51
+
52
+
53
+def _detect_cloud_provider() -> str:
54
+ # Try detecting through vendor file
55
+ vendor_files = [
56
+ "/sys/class/dmi/id/product_version", "/sys/class/dmi/id/bios_vendor",
57
+ "/sys/class/dmi/id/product_name",
58
+ "/sys/class/dmi/id/chassis_asset_tag", "/sys/class/dmi/id/sys_vendor"
59
+ ]
60
+ # Mapping of identifiable strings to cloud providers
61
+ cloud_identifiers = {
62
+ "amazon": "AWS",
63
+ "microsoft corporation": "AZURE",
64
+ "google": "GCP",
65
+ "oraclecloud": "OCI",
66
+ }
67
+
68
+ for vendor_file in vendor_files:
69
+ path = Path(vendor_file)
70
+ if path.is_file():
71
+ file_content = path.read_text().lower()
72
+ for identifier, provider in cloud_identifiers.items():
73
+ if identifier in file_content:
74
+ return provider
75
+
76
+ # Try detecting through environment variables
77
+ env_to_cloud_provider = {
78
+ "RUNPOD_DC_ID": "RUNPOD",
79
+ }
80
+ for env_var, provider in env_to_cloud_provider.items():
81
+ if os.environ.get(env_var):
82
+ return provider
83
+
84
+ return "UNKNOWN"
85
+
86
+
87
+class UsageContext(str, Enum):
88
+ UNKNOWN_CONTEXT = "UNKNOWN_CONTEXT"
89
+ LLM_CLASS = "LLM_CLASS"
90
+ API_SERVER = "API_SERVER"
91
+ OPENAI_API_SERVER = "OPENAI_API_SERVER"
92
+ ENGINE_CONTEXT = "ENGINE_CONTEXT"
93
+
94
+
95
+class UsageMessage:
96
+ """Collect platform information and send it to the usage stats server."""
97
+
98
+ def __init__(self) -> None:
99
+ # NOTE: vLLM's server _only_ support flat KV pair.
100
+ # Do not use nested fields.
101
+
102
+ self.uuid = str(uuid4())
103
+
104
+ # Environment Information
105
+ self.provider: Optional[str] = None
106
+ self.num_cpu: Optional[int] = None
107
+ self.cpu_type: Optional[str] = None
108
+ self.cpu_family_model_stepping: Optional[str] = None
109
+ self.total_memory: Optional[int] = None
110
+ self.architecture: Optional[str] = None
111
+ self.platform: Optional[str] = None
112
+ self.gpu_count: Optional[int] = None
113
+ self.gpu_type: Optional[str] = None
114
+ self.gpu_memory_per_device: Optional[int] = None
115
+
116
+ # vLLM Information
117
+ self.model_architecture: Optional[str] = None
118
+ self.vllm_version: Optional[str] = None
119
+ self.context: Optional[str] = None
120
+
121
+ # Metadata
122
+ self.log_time: Optional[int] = None
123
+ self.source: Optional[str] = None
124
+
125
+ def report_usage(self,
126
+ model_architecture: str,
127
+ usage_context: UsageContext,
128
+ extra_kvs: Dict[str, any] = None) -> None:
129
+ t = Thread(target=self._report_usage_worker,
130
+ args=(model_architecture, usage_context, extra_kvs or {}),
131
+ daemon=True)
132
+ t.start()
133
+
134
+ def _report_usage_worker(self, model_architecture: str,
135
+ usage_context: UsageContext,
136
+ extra_kvs: Dict[str, any]) -> None:
137
+ self._report_usage_once(model_architecture, usage_context, extra_kvs)
138
+ self._report_continous_usage()
139
+
140
+ def _report_usage_once(self, model_architecture: str,
141
+ usage_context: UsageContext,
142
+ extra_kvs: Dict[str, any]) -> None:
143
+ # Platform information
144
+ if torch.cuda.is_available():
145
+ device_property = torch.cuda.get_device_properties(0)
146
+ self.gpu_count = torch.cuda.device_count()
147
+ self.gpu_type = device_property.name
148
+ self.gpu_memory_per_device = device_property.total_memory
149
+ self.provider = _detect_cloud_provider()
150
+ self.architecture = platform.machine()
151
+ self.platform = platform.platform()
152
+ self.total_memory = psutil.virtual_memory().total
153
+
154
+ info = cpuinfo.get_cpu_info()
155
+ self.num_cpu = info.get("count", None)
156
+ self.cpu_type = info.get("brand_raw", "")
157
+ self.cpu_family_model_stepping = ",".join([
158
+ str(info.get("family", "")),
159
+ str(info.get("model", "")),
160
+ str(info.get("stepping", ""))
161
+ ])
162
+
163
+ # vLLM information
164
+ self.context = usage_context.value
165
+ self.vllm_version = pkg_resources.get_distribution("vllm").version
166
+ self.model_architecture = model_architecture
167
+
168
+ # Metadata
169
+ self.log_time = _get_current_timestamp_ns()
170
+ self.source = os.environ.get("VLLM_USAGE_SOURCE", "production")
171
+
172
+ data = vars(self)
173
+ if extra_kvs:
174
+ data.update(extra_kvs)
175
+
176
+ self._write_to_file(data)
177
+ self._send_to_server(data)
178
+
179
+ def _report_continous_usage(self):
180
+ """Report usage every 10 minutes.
181
+
182
+ This helps us to collect more data points for uptime of vLLM usages.
183
+ This function can also help send over performance metrics over time.
184
+ """
185
+ while True:
186
+ time.sleep(600)
187
+ data = {"uuid": self.uuid, "log_time": _get_current_timestamp_ns()}
188
+
189
+ self._write_to_file(data)
190
+ self._send_to_server(data)
191
+
192
+ def _send_to_server(self, data):
193
+ try:
194
+ requests.post(_USAGE_STATS_SERVER, json=data)
195
+ except requests.exceptions.RequestException:
196
+ # silently ignore unless we are using debug log
197
+ logging.debug("Failed to send usage data to server")
198
+
199
+ def _write_to_file(self, data):
200
+ os.makedirs(os.path.dirname(_USAGE_STATS_JSON_PATH), exist_ok=True)
201
+ Path(_USAGE_STATS_JSON_PATH).touch(exist_ok=True)
202
+ with open(_USAGE_STATS_JSON_PATH, "a") as f:
203
+ json.dump(data, f)
204
+ f.write("\n")
205
+
206
+
207
+usage_message = UsageMessage()