| // | |
| // Copyright 2018 The ANGLE Project Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| // | |
| // feature_support_util.cpp: Helps client APIs make decisions based on rules | |
| // data files. For example, the Android EGL loader uses this library to | |
| // determine whether to use ANGLE or a native GLES driver. | |
| #include "feature_support_util.h" | |
| #include <json/json.h> | |
| #include <string.h> | |
| #include "common/platform.h" | |
| #if defined(ANGLE_PLATFORM_ANDROID) | |
| # include <android/log.h> | |
| # include <unistd.h> | |
| #endif | |
| #include <fstream> | |
| #include <list> | |
| #include "../gpu_info_util/SystemInfo.h" | |
| namespace angle | |
| { | |
| #if defined(ANGLE_PLATFORM_ANDROID) | |
| // Define ANGLE_FEATURE_UTIL_LOG_VERBOSE if you want VERBOSE to output | |
| // ANGLE_FEATURE_UTIL_LOG_VERBOSE is automatically defined when is_debug = true | |
| # define ERR(...) __android_log_print(ANDROID_LOG_ERROR, "ANGLE", __VA_ARGS__) | |
| # define WARN(...) __android_log_print(ANDROID_LOG_WARN, "ANGLE", __VA_ARGS__) | |
| # define INFO(...) __android_log_print(ANDROID_LOG_INFO, "ANGLE", __VA_ARGS__) | |
| # define DEBUG(...) __android_log_print(ANDROID_LOG_DEBUG, "ANGLE", __VA_ARGS__) | |
| # ifdef ANGLE_FEATURE_UTIL_LOG_VERBOSE | |
| # define VERBOSE(...) __android_log_print(ANDROID_LOG_VERBOSE, "ANGLE", __VA_ARGS__) | |
| # else | |
| # define VERBOSE(...) ((void)0) | |
| # endif | |
| #else // defined(ANDROID) | |
| # define ERR(...) printf(__VA_ARGS__) | |
| # define WARN(...) printf(__VA_ARGS__) | |
| # define INFO(...) printf(__VA_ARGS__) | |
| # define DEBUG(...) printf(__VA_ARGS__) | |
| // Uncomment for debugging. | |
| //# define VERBOSE(...) printf(__VA_ARGS__) | |
| # define VERBOSE(...) | |
| #endif // defined(ANDROID) | |
| // JSON values are generally composed of either: | |
| // - Objects, which are a set of comma-separated string:value pairs (note the recursive nature) | |
| // - Arrays, which are a set of comma-separated values. | |
| // We'll call the string in a string:value pair the "identifier". These identifiers are defined | |
| // below, as follows: | |
| // The JSON identifier for the top-level set of rules. This is an object, the value of which is an | |
| // array of rules. The rules will be processed in order. If a rule matches, the rule's version of | |
| // the answer (true or false) becomes the new answer. After all rules are processed, the | |
| // most-recent answer is the final answer. | |
| constexpr char kJsonRules[] = "Rules"; | |
| // The JSON identifier for a given rule. A rule is an object, the first string:value pair is this | |
| // identifier (i.e. "Rule") as the string and the value is a user-firendly description of the rule: | |
| constexpr char kJsonRule[] = "Rule"; | |
| // Within a rule, the JSON identifier for the answer--whether or not to use ANGLE. The value is a | |
| // boolean (i.e. true or false). | |
| constexpr char kJsonUseANGLE[] = "UseANGLE"; | |
| // Within a rule, the JSON identifier for describing one or more applications. The value is an | |
| // array of objects, each object of which can specify attributes of an application. | |
| constexpr char kJsonApplications[] = "Applications"; | |
| // Within an object that describes the attributes of an application, the JSON identifier for the | |
| // name of the application (e.g. "com.google.maps"). The value is a string. If any other | |
| // attributes will be specified, this must be the first attribute specified in the object. | |
| constexpr char kJsonAppName[] = "AppName"; | |
| // Within a rule, the JSON identifier for describing one or more devices. The value is an | |
| // array of objects, each object of which can specify attributes of a device. | |
| constexpr char kJsonDevices[] = "Devices"; | |
| // Within an object that describes the attributes of a device, the JSON identifier for the | |
| // manufacturer of the device. The value is a string. If any other non-GPU attributes will be | |
| // specified, this must be the first attribute specified in the object. | |
| constexpr char kJsonManufacturer[] = "Manufacturer"; | |
| // Within an object that describes the attributes of a device, the JSON identifier for the | |
| // model of the device. The value is a string. | |
| constexpr char kJsonModel[] = "Model"; | |
| // Within an object that describes the attributes of a device, the JSON identifier for describing | |
| // one or more GPUs/drivers used in the device. The value is an | |
| // array of objects, each object of which can specify attributes of a GPU and its driver. | |
| constexpr char kJsonGPUs[] = "GPUs"; | |
| // Within an object that describes the attributes of a GPU and driver, the JSON identifier for the | |
| // vendor of the device/driver. The value is a string. If any other attributes will be specified, | |
| // this must be the first attribute specified in the object. | |
| constexpr char kJsonVendor[] = "Vendor"; | |
| // Within an object that describes the attributes of a GPU and driver, the JSON identifier for the | |
| // deviceId of the device. The value is an unsigned integer. If the driver version will be | |
| // specified, this must preceded the version attributes specified in the object. | |
| constexpr char kJsonDeviceId[] = "DeviceId"; | |
| // Within an object that describes the attributes of either an application or a GPU, the JSON | |
| // identifier for the major version of that application or GPU driver. The value is a positive | |
| // integer number. Not specifying a major version implies a wildcard for all values of a version. | |
| constexpr char kJsonVerMajor[] = "VerMajor"; | |
| // Within an object that describes the attributes of either an application or a GPU, the JSON | |
| // identifier for the minor version of that application or GPU driver. The value is a positive | |
| // integer number. In order to specify a minor version, it must be specified immediately after the | |
| // major number associated with it. Not specifying a minor version implies a wildcard for the | |
| // minor, subminor, and patch values of a version. | |
| constexpr char kJsonVerMinor[] = "VerMinor"; | |
| // Within an object that describes the attributes of either an application or a GPU, the JSON | |
| // identifier for the subminor version of that application or GPU driver. The value is a positive | |
| // integer number. In order to specify a subminor version, it must be specified immediately after | |
| // the minor number associated with it. Not specifying a subminor version implies a wildcard for | |
| // the subminor and patch values of a version. | |
| constexpr char kJsonVerSubMinor[] = "VerSubMinor"; | |
| // Within an object that describes the attributes of either an application or a GPU, the JSON | |
| // identifier for the patch version of that application or GPU driver. The value is a positive | |
| // integer number. In order to specify a patch version, it must be specified immediately after the | |
| // subminor number associated with it. Not specifying a patch version implies a wildcard for the | |
| // patch value of a version. | |
| constexpr char kJsonVerPatch[] = "VerPatch"; | |
| // This encapsulates a std::string. The default constructor (not given a string) assumes that this | |
| // is a wildcard (i.e. will match all other StringPart objects). | |
| class StringPart | |
| { | |
| public: | |
| StringPart() : mPart(""), mWildcard(true) {} | |
| StringPart(const std::string part) : mPart(part), mWildcard(false) {} | |
| ~StringPart() {} | |
| bool match(const StringPart &toCheck) const | |
| { | |
| return (mWildcard || toCheck.mWildcard || (toCheck.mPart == mPart)); | |
| } | |
| public: | |
| std::string mPart; | |
| bool mWildcard; | |
| }; | |
| // This encapsulates a 32-bit unsigned integer. The default constructor (not given a number) | |
| // assumes that this is a wildcard (i.e. will match all other IntegerPart objects). | |
| class IntegerPart | |
| { | |
| public: | |
| IntegerPart() : mPart(0), mWildcard(true) {} | |
| IntegerPart(uint32_t part) : mPart(part), mWildcard(false) {} | |
| ~IntegerPart() {} | |
| bool match(const IntegerPart &toCheck) const | |
| { | |
| return (mWildcard || toCheck.mWildcard || (toCheck.mPart == mPart)); | |
| } | |
| public: | |
| uint32_t mPart; | |
| bool mWildcard; | |
| }; | |
| // This encapsulates a list of other classes, each of which will have a match() and logItem() | |
| // method. The common constructor (given a type, but not any list items) assumes that this is | |
| // a wildcard (i.e. will match all other ListOf<t> objects). | |
| template <class T> | |
| class ListOf | |
| { | |
| public: | |
| ListOf(const std::string listType) : mWildcard(true), mListType(listType) {} | |
| ~ListOf() { mList.clear(); } | |
| void addItem(const T &toAdd) | |
| { | |
| mList.push_back(toAdd); | |
| mWildcard = false; | |
| } | |
| bool match(const T &toCheck) const | |
| { | |
| VERBOSE("\t\t Within ListOf<%s> match: wildcards are %s and %s,\n", mListType.c_str(), | |
| mWildcard ? "true" : "false", toCheck.mWildcard ? "true" : "false"); | |
| if (mWildcard || toCheck.mWildcard) | |
| { | |
| return true; | |
| } | |
| for (const T &it : mList) | |
| { | |
| VERBOSE("\t\t Within ListOf<%s> match: calling match on sub-item is %s,\n", | |
| mListType.c_str(), it.match(toCheck) ? "true" : "false"); | |
| if (it.match(toCheck)) | |
| { | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool match(const ListOf<T> &toCheck) const | |
| { | |
| VERBOSE("\t\t Within ListOf<%s> match: wildcards are %s and %s,\n", mListType.c_str(), | |
| mWildcard ? "true" : "false", toCheck.mWildcard ? "true" : "false"); | |
| if (mWildcard || toCheck.mWildcard) | |
| { | |
| return true; | |
| } | |
| // If we make it to here, both this and toCheck have at least one item in their mList | |
| for (const T &it : toCheck.mList) | |
| { | |
| if (match(it)) | |
| { | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| void logListOf(const std::string prefix, const std::string name) const | |
| { | |
| if (mWildcard) | |
| { | |
| VERBOSE("%sListOf%s is wildcarded to always match", prefix.c_str(), name.c_str()); | |
| } | |
| else | |
| { | |
| VERBOSE("%sListOf%s has %d item(s):", prefix.c_str(), name.c_str(), | |
| static_cast<int>(mList.size())); | |
| for (auto &it : mList) | |
| { | |
| it.logItem(); | |
| } | |
| } | |
| } | |
| bool mWildcard; | |
| private: | |
| std::string mListType; | |
| std::vector<T> mList; | |
| }; | |
| // This encapsulates up-to four 32-bit unsigned integers, that represent a potentially-complex | |
| // version number. The default constructor (not given any numbers) assumes that this is a wildcard | |
| // (i.e. will match all other Version objects). Each part of a Version is stored in an IntegerPart | |
| // class, and so may be wildcarded as well. | |
| class Version | |
| { | |
| public: | |
| Version(uint32_t major, uint32_t minor, uint32_t subminor, uint32_t patch) | |
| : mMajor(major), mMinor(minor), mSubminor(subminor), mPatch(patch), mWildcard(false) | |
| {} | |
| Version(uint32_t major, uint32_t minor, uint32_t subminor) | |
| : mMajor(major), mMinor(minor), mSubminor(subminor), mWildcard(false) | |
| {} | |
| Version(uint32_t major, uint32_t minor) : mMajor(major), mMinor(minor), mWildcard(false) {} | |
| Version(uint32_t major) : mMajor(major), mWildcard(false) {} | |
| Version() : mWildcard(true) {} | |
| Version(const Version &toCopy) | |
| : mMajor(toCopy.mMajor), | |
| mMinor(toCopy.mMinor), | |
| mSubminor(toCopy.mSubminor), | |
| mPatch(toCopy.mPatch), | |
| mWildcard(toCopy.mWildcard) | |
| {} | |
| ~Version() {} | |
| static Version *CreateVersionFromJson(const Json::Value &jObject) | |
| { | |
| Version *version = nullptr; | |
| // A major version must be provided before a minor, and so on: | |
| if (jObject.isMember(kJsonVerMajor) && jObject[kJsonVerMajor].isInt()) | |
| { | |
| int major = jObject[kJsonVerMajor].asInt(); | |
| if (jObject.isMember(kJsonVerMinor) && jObject[kJsonVerMinor].isInt()) | |
| { | |
| int minor = jObject[kJsonVerMinor].asInt(); | |
| if (jObject.isMember(kJsonVerSubMinor) && jObject[kJsonVerSubMinor].isInt()) | |
| { | |
| int subMinor = jObject[kJsonVerSubMinor].asInt(); | |
| if (jObject.isMember(kJsonVerPatch) && jObject[kJsonVerPatch].isInt()) | |
| { | |
| int patch = jObject[kJsonVerPatch].asInt(); | |
| version = new Version(major, minor, subMinor, patch); | |
| } | |
| else | |
| { | |
| version = new Version(major, minor, subMinor); | |
| } | |
| } | |
| else | |
| { | |
| version = new Version(major, minor); | |
| } | |
| } | |
| else | |
| { | |
| version = new Version(major); | |
| } | |
| } | |
| return version; | |
| } | |
| bool match(const Version &toCheck) const | |
| { | |
| VERBOSE("\t\t\t Within Version %d,%d,%d,%d match(%d,%d,%d,%d): wildcards are %s and %s,\n", | |
| mMajor.mPart, mMinor.mPart, mSubminor.mPart, mPatch.mPart, toCheck.mMajor.mPart, | |
| toCheck.mMinor.mPart, toCheck.mSubminor.mPart, toCheck.mPatch.mPart, | |
| mWildcard ? "true" : "false", toCheck.mWildcard ? "true" : "false"); | |
| if (!(mWildcard || toCheck.mWildcard)) | |
| { | |
| VERBOSE("\t\t\t mMajor match is %s, mMinor is %s, mSubminor is %s, mPatch is %s\n", | |
| mMajor.match(toCheck.mMajor) ? "true" : "false", | |
| mMinor.match(toCheck.mMinor) ? "true" : "false", | |
| mSubminor.match(toCheck.mSubminor) ? "true" : "false", | |
| mPatch.match(toCheck.mPatch) ? "true" : "false"); | |
| } | |
| return (mWildcard || toCheck.mWildcard || | |
| (mMajor.match(toCheck.mMajor) && mMinor.match(toCheck.mMinor) && | |
| mSubminor.match(toCheck.mSubminor) && mPatch.match(toCheck.mPatch))); | |
| } | |
| std::string getString() const | |
| { | |
| if (mWildcard) | |
| { | |
| return "*"; | |
| } | |
| else | |
| { | |
| char ret[100]; | |
| // Must at least have a major version: | |
| if (!mMinor.mWildcard) | |
| { | |
| if (!mSubminor.mWildcard) | |
| { | |
| if (!mPatch.mWildcard) | |
| { | |
| snprintf(ret, 100, "%d.%d.%d.%d", mMajor.mPart, mMinor.mPart, | |
| mSubminor.mPart, mPatch.mPart); | |
| } | |
| else | |
| { | |
| snprintf(ret, 100, "%d.%d.%d.*", mMajor.mPart, mMinor.mPart, | |
| mSubminor.mPart); | |
| } | |
| } | |
| else | |
| { | |
| snprintf(ret, 100, "%d.%d.*", mMajor.mPart, mMinor.mPart); | |
| } | |
| } | |
| else | |
| { | |
| snprintf(ret, 100, "%d.*", mMajor.mPart); | |
| } | |
| std::string retString = ret; | |
| return retString; | |
| } | |
| } | |
| public: | |
| IntegerPart mMajor; | |
| IntegerPart mMinor; | |
| IntegerPart mSubminor; | |
| IntegerPart mPatch; | |
| bool mWildcard; | |
| }; | |
| // This encapsulates an application, and potentially the application's Version. The default | |
| // constructor (not given any values) assumes that this is a wildcard (i.e. will match all | |
| // other Application objects). Each part of an Application is stored in a class that may | |
| // also be wildcarded. | |
| class Application | |
| { | |
| public: | |
| Application(const std::string name, const Version &version) | |
| : mName(name), mVersion(version), mWildcard(false) | |
| {} | |
| Application(const std::string name) : mName(name), mVersion(), mWildcard(false) {} | |
| Application() : mName(), mVersion(), mWildcard(true) {} | |
| ~Application() {} | |
| static Application *CreateApplicationFromJson(const Json::Value &jObject) | |
| { | |
| Application *application = nullptr; | |
| // If an application is listed, the application's name is required: | |
| std::string appName = jObject[kJsonAppName].asString(); | |
| // The application's version is optional: | |
| Version *version = Version::CreateVersionFromJson(jObject); | |
| if (version) | |
| { | |
| application = new Application(appName, *version); | |
| delete version; | |
| } | |
| else | |
| { | |
| application = new Application(appName); | |
| } | |
| return application; | |
| } | |
| bool match(const Application &toCheck) const | |
| { | |
| return (mWildcard || toCheck.mWildcard || | |
| (toCheck.mName.match(mName) && toCheck.mVersion.match(mVersion))); | |
| } | |
| void logItem() const | |
| { | |
| if (mWildcard) | |
| { | |
| VERBOSE(" Wildcard (i.e. will match all applications)"); | |
| } | |
| else if (!mVersion.mWildcard) | |
| { | |
| VERBOSE(" Application \"%s\" (version: %s)", mName.mPart.c_str(), | |
| mVersion.getString().c_str()); | |
| } | |
| else | |
| { | |
| VERBOSE(" Application \"%s\"", mName.mPart.c_str()); | |
| } | |
| } | |
| public: | |
| StringPart mName; | |
| Version mVersion; | |
| bool mWildcard; | |
| }; | |
| // This encapsulates a GPU and its driver. The default constructor (not given any values) assumes | |
| // that this is a wildcard (i.e. will match all other GPU objects). Each part of a GPU is stored | |
| // in a class that may also be wildcarded. | |
| class GPU | |
| { | |
| public: | |
| GPU(const std::string vendor, uint32_t deviceId, const Version &version) | |
| : mVendor(vendor), mDeviceId(IntegerPart(deviceId)), mVersion(version), mWildcard(false) | |
| {} | |
| GPU(const std::string vendor, uint32_t deviceId) | |
| : mVendor(vendor), mDeviceId(IntegerPart(deviceId)), mVersion(), mWildcard(false) | |
| {} | |
| GPU(const std::string vendor) : mVendor(vendor), mDeviceId(), mVersion(), mWildcard(false) {} | |
| GPU() : mVendor(), mDeviceId(), mVersion(), mWildcard(true) {} | |
| bool match(const GPU &toCheck) const | |
| { | |
| VERBOSE("\t\t Within GPU match: wildcards are %s and %s,\n", mWildcard ? "true" : "false", | |
| toCheck.mWildcard ? "true" : "false"); | |
| VERBOSE("\t\t mVendor = \"%s\" and toCheck.mVendor = \"%s\"\n", mVendor.mPart.c_str(), | |
| toCheck.mVendor.mPart.c_str()); | |
| VERBOSE("\t\t mDeviceId = %d and toCheck.mDeviceId = %d\n", mDeviceId.mPart, | |
| toCheck.mDeviceId.mPart); | |
| VERBOSE("\t\t mVendor match is %s, mDeviceId is %s, mVersion is %s\n", | |
| toCheck.mVendor.match(mVendor) ? "true" : "false", | |
| toCheck.mDeviceId.match(mDeviceId) ? "true" : "false", | |
| toCheck.mVersion.match(mVersion) ? "true" : "false"); | |
| return (mWildcard || toCheck.mWildcard || | |
| (toCheck.mVendor.match(mVendor) && toCheck.mDeviceId.match(mDeviceId) && | |
| toCheck.mVersion.match(mVersion))); | |
| } | |
| ~GPU() {} | |
| static GPU *CreateGpuFromJson(const Json::Value &jObject) | |
| { | |
| GPU *gpu = nullptr; | |
| // If a GPU is listed, the vendor name is required: | |
| if (jObject.isMember(kJsonVendor) && jObject[kJsonVendor].isString()) | |
| { | |
| std::string vendor = jObject[kJsonVendor].asString(); | |
| // If a version is given, the deviceId is required: | |
| if (jObject.isMember(kJsonDeviceId) && jObject[kJsonDeviceId].isUInt()) | |
| { | |
| uint32_t deviceId = jObject[kJsonDeviceId].asUInt(); | |
| Version *version = Version::CreateVersionFromJson(jObject); | |
| if (version) | |
| { | |
| gpu = new GPU(vendor, deviceId, *version); | |
| delete version; | |
| } | |
| else | |
| { | |
| gpu = new GPU(vendor, deviceId); | |
| } | |
| } | |
| else | |
| { | |
| gpu = new GPU(vendor); | |
| } | |
| } | |
| else | |
| { | |
| WARN("Asked to parse a GPU, but no vendor found"); | |
| } | |
| return gpu; | |
| } | |
| void logItem() const | |
| { | |
| if (mWildcard) | |
| { | |
| VERBOSE(" Wildcard (i.e. will match all GPUs)"); | |
| } | |
| else | |
| { | |
| if (!mDeviceId.mWildcard) | |
| { | |
| if (!mVersion.mWildcard) | |
| { | |
| VERBOSE("\t GPU vendor: %s, deviceId: 0x%x, version: %s", | |
| mVendor.mPart.c_str(), mDeviceId.mPart, mVersion.getString().c_str()); | |
| } | |
| else | |
| { | |
| VERBOSE("\t GPU vendor: %s, deviceId: 0x%x", mVendor.mPart.c_str(), | |
| mDeviceId.mPart); | |
| } | |
| } | |
| else | |
| { | |
| VERBOSE("\t GPU vendor: %s", mVendor.mPart.c_str()); | |
| } | |
| } | |
| } | |
| public: | |
| StringPart mVendor; | |
| IntegerPart mDeviceId; | |
| Version mVersion; | |
| bool mWildcard; | |
| }; | |
| // This encapsulates a device, and potentially the device's model and/or a list of GPUs/drivers | |
| // associated with the Device. The default constructor (not given any values) assumes that this is | |
| // a wildcard (i.e. will match all other Device objects). Each part of a Device is stored in a | |
| // class that may also be wildcarded. | |
| class Device | |
| { | |
| public: | |
| Device(const std::string manufacturer, const std::string model) | |
| : mManufacturer(manufacturer), mModel(model), mGpuList("GPU"), mWildcard(false) | |
| {} | |
| Device(const std::string manufacturer) | |
| : mManufacturer(manufacturer), mModel(), mGpuList("GPU"), mWildcard(false) | |
| {} | |
| Device() : mManufacturer(), mModel(), mGpuList("GPU"), mWildcard(true) {} | |
| ~Device() {} | |
| static Device *CreateDeviceFromJson(const Json::Value &jObject) | |
| { | |
| Device *device = nullptr; | |
| if (jObject.isMember(kJsonManufacturer) && jObject[kJsonManufacturer].isString()) | |
| { | |
| std::string manufacturerName = jObject[kJsonManufacturer].asString(); | |
| // We don't let a model be specified without also specifying an Manufacturer: | |
| if (jObject.isMember(kJsonModel) && jObject[kJsonModel].isString()) | |
| { | |
| std::string model = jObject[kJsonModel].asString(); | |
| device = new Device(manufacturerName, model); | |
| } | |
| else | |
| { | |
| device = new Device(manufacturerName); | |
| } | |
| } | |
| else | |
| { | |
| // This case is not treated as an error because a rule may wish to only call out one or | |
| // more GPUs, but not any specific Manufacturer (e.g. for any manufacturer's device | |
| // that uses a GPU from Vendor-A, with DeviceID-Foo, and with driver version 1.2.3.4): | |
| device = new Device(); | |
| } | |
| return device; | |
| } | |
| void addGPU(const GPU &gpu) { mGpuList.addItem(gpu); } | |
| bool match(const Device &toCheck) const | |
| { | |
| VERBOSE("\t Within Device match: wildcards are %s and %s,\n", mWildcard ? "true" : "false", | |
| toCheck.mWildcard ? "true" : "false"); | |
| if (!(mWildcard || toCheck.mWildcard)) | |
| { | |
| VERBOSE("\t Manufacturer match is %s, model is %s\n", | |
| toCheck.mManufacturer.match(mManufacturer) ? "true" : "false", | |
| toCheck.mModel.match(mModel) ? "true" : "false"); | |
| } | |
| VERBOSE("\t Need to check ListOf<GPU>\n"); | |
| return ((mWildcard || toCheck.mWildcard || | |
| // The wildcards can override the Manufacturer/Model check, but not the GPU check | |
| (toCheck.mManufacturer.match(mManufacturer) && toCheck.mModel.match(mModel))) && | |
| mGpuList.match(toCheck.mGpuList)); | |
| } | |
| void logItem() const | |
| { | |
| if (mWildcard) | |
| { | |
| if (mGpuList.mWildcard) | |
| { | |
| VERBOSE(" Wildcard (i.e. will match all devices)"); | |
| return; | |
| } | |
| else | |
| { | |
| VERBOSE( | |
| " Device with any manufacturer and model" | |
| ", and with the following GPUs:"); | |
| } | |
| } | |
| else | |
| { | |
| if (!mModel.mWildcard) | |
| { | |
| VERBOSE( | |
| " Device manufacturer: \"%s\" and model \"%s\"" | |
| ", and with the following GPUs:", | |
| mManufacturer.mPart.c_str(), mModel.mPart.c_str()); | |
| } | |
| else | |
| { | |
| VERBOSE( | |
| " Device manufacturer: \"%s\"" | |
| ", and with the following GPUs:", | |
| mManufacturer.mPart.c_str()); | |
| } | |
| } | |
| mGpuList.logListOf(" ", "GPUs"); | |
| } | |
| public: | |
| StringPart mManufacturer; | |
| StringPart mModel; | |
| ListOf<GPU> mGpuList; | |
| bool mWildcard; | |
| }; | |
| // This encapsulates a particular scenario to check against the rules. A Scenario is similar to a | |
| // Rule, except that a Rule has an answer and potentially many wildcards, and a Scenario is the | |
| // fully-specified combination of an Application and a Device that is proposed to be run with | |
| // ANGLE. It is compared with the list of Rules. | |
| class Scenario | |
| { | |
| public: | |
| Scenario(const char *appName, const char *deviceMfr, const char *deviceModel) | |
| : mApplication(Application(appName)), mDevice(Device(deviceMfr, deviceModel)) | |
| {} | |
| ~Scenario() {} | |
| void logScenario() | |
| { | |
| VERBOSE(" Scenario to compare against the rules"); | |
| VERBOSE(" Application:"); | |
| mApplication.logItem(); | |
| VERBOSE(" Device:"); | |
| mDevice.logItem(); | |
| } | |
| public: | |
| Application mApplication; | |
| Device mDevice; | |
| }; | |
| // This encapsulates a Rule that provides an answer based on whether a particular Scenario matches | |
| // the Rule. A Rule always has an answer, but can potentially wildcard every item in it (i.e. | |
| // match every scenario). | |
| class Rule | |
| { | |
| public: | |
| Rule(const std::string description, bool useANGLE) | |
| : mDescription(description), | |
| mAppList("Application"), | |
| mDevList("Device"), | |
| mUseANGLE(useANGLE) | |
| {} | |
| ~Rule() {} | |
| void addApp(const Application &app) { mAppList.addItem(app); } | |
| void addDevice(const Device &dev) { mDevList.addItem(dev); } | |
| bool match(const Scenario &toCheck) const | |
| { | |
| VERBOSE(" Within \"%s\" Rule: application match is %s and device match is %s\n", | |
| mDescription.c_str(), mAppList.match(toCheck.mApplication) ? "true" : "false", | |
| mDevList.match(toCheck.mDevice) ? "true" : "false"); | |
| return (mAppList.match(toCheck.mApplication) && mDevList.match(toCheck.mDevice)); | |
| } | |
| bool getUseANGLE() const { return mUseANGLE; } | |
| void logRule() const | |
| { | |
| VERBOSE(" Rule: \"%s\" %s ANGLE", mDescription.c_str(), | |
| mUseANGLE ? "enables" : "disables"); | |
| mAppList.logListOf(" ", "Applications"); | |
| mDevList.logListOf(" ", "Devices"); | |
| } | |
| std::string mDescription; | |
| ListOf<Application> mAppList; | |
| ListOf<Device> mDevList; | |
| bool mUseANGLE; | |
| }; | |
| // This encapsulates a list of Rules that Scenarios are matched against. A Scenario is compared | |
| // with each Rule, in order. Any time a Scenario matches a Rule, the current answer is overridden | |
| // with the answer of the matched Rule. | |
| class RuleList | |
| { | |
| public: | |
| RuleList() {} | |
| ~RuleList() { mRuleList.clear(); } | |
| static RuleList *ReadRulesFromJsonString(const std::string jsonFileContents) | |
| { | |
| RuleList *rules = new RuleList; | |
| // Open the file and start parsing it: | |
| Json::Reader jReader; | |
| Json::Value jTopLevelObject; | |
| jReader.parse(jsonFileContents, jTopLevelObject); | |
| Json::Value jRules = jTopLevelObject[kJsonRules]; | |
| for (unsigned int ruleIndex = 0; ruleIndex < jRules.size(); ruleIndex++) | |
| { | |
| Json::Value jRule = jRules[ruleIndex]; | |
| std::string ruleDescription = jRule[kJsonRule].asString(); | |
| bool useANGLE = jRule[kJsonUseANGLE].asBool(); | |
| Rule *newRule = new Rule(ruleDescription, useANGLE); | |
| Json::Value jApps = jRule[kJsonApplications]; | |
| for (unsigned int appIndex = 0; appIndex < jApps.size(); appIndex++) | |
| { | |
| Json::Value jApp = jApps[appIndex]; | |
| Application *newApp = Application::CreateApplicationFromJson(jApp); | |
| newRule->addApp(*newApp); | |
| delete newApp; | |
| } | |
| Json::Value jDevs = jRule[kJsonDevices]; | |
| for (unsigned int deviceIndex = 0; deviceIndex < jDevs.size(); deviceIndex++) | |
| { | |
| Json::Value jDev = jDevs[deviceIndex]; | |
| Device *newDev = Device::CreateDeviceFromJson(jDev); | |
| Json::Value jGPUs = jDev[kJsonGPUs]; | |
| for (unsigned int gpuIndex = 0; gpuIndex < jGPUs.size(); gpuIndex++) | |
| { | |
| Json::Value jGPU = jGPUs[gpuIndex]; | |
| GPU *newGPU = GPU::CreateGpuFromJson(jGPU); | |
| if (newGPU) | |
| { | |
| newDev->addGPU(*newGPU); | |
| delete newGPU; | |
| } | |
| } | |
| newRule->addDevice(*newDev); | |
| delete newDev; | |
| } | |
| rules->addRule(*newRule); | |
| delete newRule; | |
| } | |
| // Make sure there is at least one, default rule. If not, add it here: | |
| if (rules->mRuleList.size() == 0) | |
| { | |
| Rule defaultRule("Default Rule", false); | |
| rules->addRule(defaultRule); | |
| } | |
| return rules; | |
| } | |
| void addRule(const Rule &rule) { mRuleList.push_back(rule); } | |
| bool getUseANGLE(const Scenario &toCheck) | |
| { | |
| // Initialize useANGLE to the system-wide default (that should be set in the default | |
| // rule, but just in case, set it here too): | |
| bool useANGLE = false; | |
| VERBOSE("Checking scenario against %d ANGLE-for-Android rules:", | |
| static_cast<int>(mRuleList.size())); | |
| for (const Rule &rule : mRuleList) | |
| { | |
| VERBOSE(" Checking Rule: \"%s\" (to see whether there's a match)", | |
| rule.mDescription.c_str()); | |
| if (rule.match(toCheck)) | |
| { | |
| VERBOSE(" -> Rule matches. Setting useANGLE to %s", | |
| rule.getUseANGLE() ? "true" : "false"); | |
| useANGLE = rule.getUseANGLE(); | |
| } | |
| else | |
| { | |
| VERBOSE(" -> Rule doesn't match."); | |
| } | |
| } | |
| return useANGLE; | |
| } | |
| void logRules() | |
| { | |
| VERBOSE("Showing %d ANGLE-for-Android rules:", static_cast<int>(mRuleList.size())); | |
| for (const Rule &rule : mRuleList) | |
| { | |
| rule.logRule(); | |
| } | |
| } | |
| public: | |
| std::vector<Rule> mRuleList; | |
| }; | |
| } // namespace angle | |
| extern "C" { | |
| using namespace angle; | |
| // This function is part of the version-2 API: | |
| ANGLE_EXPORT bool ANGLEGetFeatureSupportUtilAPIVersion(unsigned int *versionToUse) | |
| { | |
| if (!versionToUse || (*versionToUse < kFeatureVersion_LowestSupported)) | |
| { | |
| // The versionToUse is either nullptr or is less than the lowest version supported, which | |
| // is an error. | |
| return false; | |
| } | |
| if (*versionToUse > kFeatureVersion_HighestSupported) | |
| { | |
| // The versionToUse is greater than the highest version supported; change it to the | |
| // highest version supported (caller will decide if it can use that version). | |
| *versionToUse = kFeatureVersion_HighestSupported; | |
| } | |
| return true; | |
| } | |
| // This function is part of the version-2 API: | |
| ANGLE_EXPORT bool ANGLEAndroidParseRulesString(const char *rulesString, | |
| RulesHandle *rulesHandle, | |
| int *rulesVersion) | |
| { | |
| if (!rulesString || !rulesHandle || !rulesVersion) | |
| { | |
| return false; | |
| } | |
| std::string rulesFileContents = rulesString; | |
| RuleList *rules = RuleList::ReadRulesFromJsonString(rulesFileContents); | |
| rules->logRules(); | |
| *rulesHandle = rules; | |
| *rulesVersion = 0; | |
| return true; | |
| } | |
| // This function is part of the version-2 API: | |
| ANGLE_EXPORT bool ANGLEGetSystemInfo(SystemInfoHandle *systemInfoHandle) | |
| { | |
| if (!systemInfoHandle) | |
| { | |
| return false; | |
| } | |
| // TODO (http://anglebug.com/3036): Restore the real code | |
| angle::SystemInfo *systemInfo = new angle::SystemInfo; | |
| systemInfo->gpus.resize(1); | |
| GPUDeviceInfo &gpu = systemInfo->gpus[0]; | |
| gpu.vendorId = 0xFEFEFEFE; | |
| gpu.deviceId = 0xFEEEFEEE; | |
| gpu.driverVendor = "Foo"; | |
| gpu.driverVersion = "1.2.3.4"; | |
| *systemInfoHandle = systemInfo; | |
| return true; | |
| } | |
| // This function is part of the version-2 API: | |
| ANGLE_EXPORT bool ANGLEAddDeviceInfoToSystemInfo(const char *deviceMfr, | |
| const char *deviceModel, | |
| SystemInfoHandle systemInfoHandle) | |
| { | |
| angle::SystemInfo *systemInfo = static_cast<angle::SystemInfo *>(systemInfoHandle); | |
| if (!deviceMfr || !deviceModel || !systemInfo) | |
| { | |
| return false; | |
| } | |
| systemInfo->machineManufacturer = deviceMfr; | |
| systemInfo->machineModelName = deviceModel; | |
| return true; | |
| } | |
| // This function is part of the version-2 API: | |
| ANGLE_EXPORT bool ANGLEShouldBeUsedForApplication(const RulesHandle rulesHandle, | |
| int rulesVersion, | |
| const SystemInfoHandle systemInfoHandle, | |
| const char *appName) | |
| { | |
| RuleList *rules = static_cast<RuleList *>(rulesHandle); | |
| angle::SystemInfo *systemInfo = static_cast<angle::SystemInfo *>(systemInfoHandle); | |
| if (!rules || !systemInfo || !appName || (systemInfo->gpus.size() != 1)) | |
| { | |
| return false; | |
| } | |
| Scenario scenario(appName, systemInfo->machineManufacturer.c_str(), | |
| systemInfo->machineModelName.c_str()); | |
| Version gpuDriverVersion(systemInfo->gpus[0].detailedDriverVersion.major, | |
| systemInfo->gpus[0].detailedDriverVersion.minor, | |
| systemInfo->gpus[0].detailedDriverVersion.subMinor, | |
| systemInfo->gpus[0].detailedDriverVersion.patch); | |
| GPU gpuDriver(systemInfo->gpus[0].driverVendor, systemInfo->gpus[0].deviceId, gpuDriverVersion); | |
| scenario.mDevice.addGPU(gpuDriver); | |
| scenario.logScenario(); | |
| bool rtn = rules->getUseANGLE(scenario); | |
| VERBOSE("Application \"%s\" should %s ANGLE", appName, rtn ? "use" : "NOT use"); | |
| return rtn; | |
| } | |
| // This function is part of the version-2 API: | |
| ANGLE_EXPORT void ANGLEFreeRulesHandle(const RulesHandle rulesHandle) | |
| { | |
| RuleList *rules = static_cast<RuleList *>(rulesHandle); | |
| if (rules) | |
| { | |
| delete rules; | |
| } | |
| } | |
| // This function is part of the version-2 API: | |
| ANGLE_EXPORT void ANGLEFreeSystemInfoHandle(const SystemInfoHandle systemInfoHandle) | |
| { | |
| angle::SystemInfo *systemInfo = static_cast<angle::SystemInfo *>(systemInfoHandle); | |
| if (systemInfo) | |
| { | |
| delete systemInfo; | |
| } | |
| } | |
| } // extern "C" |