| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * |
| * Licensed 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. |
| */ |
| |
| #include <gapir/context.h> |
| #include <gapir/memory_manager.h> |
| #include <gapir/resource_disk_cache.h> |
| #include <gapir/resource_in_memory_cache.h> |
| #include <gapir/resource_requester.h> |
| #include <gapir/server_connection.h> |
| #include <gapir/server_listener.h> |
| |
| #include <gapic/connection.h> |
| #include <gapic/log.h> |
| #include <gapic/socket_connection.h> |
| #include <gapic/target.h> |
| |
| #include <memory> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #if TARGET_OS == GAPID_OS_ANDROID |
| #include <android_native_app_glue.h> |
| #endif // TARGET_OS == GAPID_OS_ANDROID |
| |
| using namespace gapic; |
| using namespace gapir; |
| |
| namespace { |
| |
| std::vector<uint32_t> memorySizes{ |
| 2 * 1024 * 1024 * 1024U, // 2GB |
| 1 * 1024 * 1024 * 1024U, // 1GB |
| 512 * 1024 * 1024U, // 512MB |
| 256 * 1024 * 1024U, // 256MB |
| 128 * 1024 * 1024U, // 128MB |
| }; |
| |
| // createResourceProvider constructs and returns a ResourceInMemoryCache. |
| // If cachePath is non-null then the ResourceInMemoryCache will be backed by a |
| // disk-cache. |
| std::unique_ptr<ResourceInMemoryCache> createResourceProvider( |
| const char* cachePath, MemoryManager* memoryManager) { |
| if (cachePath != nullptr) { |
| GAPID_FATAL("Disk cache is currently out of service. Got %s", cachePath); |
| return std::unique_ptr<ResourceInMemoryCache>( |
| ResourceInMemoryCache::create( |
| ResourceDiskCache::create(ResourceRequester::create(), cachePath), |
| memoryManager->getBaseAddress())); |
| } else { |
| return std::unique_ptr<ResourceInMemoryCache>( |
| ResourceInMemoryCache::create( |
| ResourceRequester::create(), memoryManager->getBaseAddress())); |
| } |
| } |
| |
| void listenConnections(std::unique_ptr<Connection> conn, |
| const char* authToken, |
| const char* cachePath, |
| int idleTimeoutMs, |
| MemoryManager* memoryManager) { |
| ServerListener listener(std::move(conn), memoryManager->getSize()); |
| |
| std::unique_ptr<ResourceInMemoryCache> resourceProvider( |
| createResourceProvider(cachePath, memoryManager)); |
| |
| while (true) { |
| std::unique_ptr<ServerConnection> acceptedConn( |
| listener.acceptConnection(idleTimeoutMs, authToken)); |
| if (!acceptedConn) { |
| GAPID_INFO("Shutting down"); |
| break; |
| } |
| |
| std::unique_ptr<Context> context = |
| Context::create(*acceptedConn, resourceProvider.get(), memoryManager); |
| if (context == nullptr) { |
| GAPID_WARNING("Loading Context failed!"); |
| continue; |
| } |
| |
| context->prefetch(resourceProvider.get()); |
| |
| if (!context->interpret()) { |
| GAPID_DEBUG("Interpret returned false"); |
| } |
| } |
| } |
| |
| } // anonymous namespace |
| |
| #if TARGET_OS == GAPID_OS_ANDROID |
| // Main function for android |
| void android_main(struct android_app* app) { |
| app_dummy(); |
| MemoryManager memoryManager(memorySizes); |
| auto conn = SocketConnection::createPipe("gapir", ""); |
| if (conn == nullptr) { |
| GAPID_FATAL("Failed to create abstract local port: gapir"); |
| } |
| // Note if you want to create a disk cache create it under: |
| // app->activity->internalDataPath |
| listenConnections(std::move(conn), nullptr, nullptr, Connection::NO_TIMEOUT, &memoryManager); |
| } |
| |
| #else // TARGET_OS == GAPID_OS_ANDROID |
| // Main function for PC |
| int main(int argc, const char* argv[]) { |
| const char* logPath = "logs/gapir.log"; |
| |
| const char* cachePath = nullptr; |
| const char* portStr = "0"; |
| const char* authToken = nullptr; |
| int idleTimeoutMs = Connection::NO_TIMEOUT; |
| |
| for (int i = 1; i < argc; i++) { |
| if (strcmp(argv[i], "--auth-token") == 0) { |
| if (i + 1 >= argc) { |
| GAPID_FATAL("Usage: --auth-token <token-string>"); |
| } |
| authToken = argv[++i]; |
| } else if (strcmp(argv[i], "--cache") == 0) { |
| if (i + 1 >= argc) { |
| GAPID_FATAL("Usage: --cache <cache-directory>"); |
| } |
| cachePath = argv[++i]; |
| } else if (strcmp(argv[i], "--port") == 0) { |
| if (i + 1 >= argc) { |
| GAPID_FATAL("Usage: --port <port_num>"); |
| } |
| portStr = argv[++i]; |
| } else if (strcmp(argv[i], "--log") == 0) { |
| if (i + 1 >= argc) { |
| GAPID_FATAL("Usage: --log <log-file-path>"); |
| } |
| logPath = argv[++i]; |
| } else if (strcmp(argv[i], "--idle-timeout-ms") == 0) { |
| if (i + 1 >= argc) { |
| GAPID_FATAL("Usage: --idle-timeout-ms <timeout in milliseconds>"); |
| } |
| idleTimeoutMs = atoi(argv[++i]); |
| } else { |
| GAPID_FATAL("Unknown argument: %s", argv[i]); |
| } |
| } |
| |
| GAPID_LOGGER_INIT(logPath); |
| |
| MemoryManager memoryManager(memorySizes); |
| GAPID_INFO("gapir listening on port %s", portStr); |
| auto conn = SocketConnection::createSocket("127.0.0.1", portStr); |
| if (conn == nullptr) { |
| GAPID_FATAL("Failed to create listening socket on port: %s", portStr); |
| } |
| listenConnections(std::move(conn), authToken, cachePath, idleTimeoutMs, &memoryManager); |
| return EXIT_SUCCESS; |
| } |
| |
| #endif // TARGET_OS == GAPID_OS_ANDROID |