You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
238 lines
8.8 KiB
238 lines
8.8 KiB
/*
|
|
* Copyright (C) 2015 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.
|
|
*/
|
|
|
|
#ifndef ANDROID_RENDERSCRIPT_EXECUTABLE_H
|
|
#define ANDROID_RENDERSCRIPT_EXECUTABLE_H
|
|
|
|
|
|
#include "rsCpuScript.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <string>
|
|
|
|
namespace android {
|
|
namespace renderscript {
|
|
|
|
class Context;
|
|
|
|
class SharedLibraryUtils {
|
|
public:
|
|
#ifndef RS_COMPATIBILITY_LIB
|
|
// Creates a shared library in cacheDir for the bitcode named resName.
|
|
// If reuse is false and SOPath is not nullptr, saves the filename
|
|
// used for the shared library in SOPath.
|
|
static bool createSharedLibrary(const char* driverName,
|
|
const char* cacheDir,
|
|
const char* resName,
|
|
const bool reuse = true,
|
|
std::string *SOPath = nullptr);
|
|
#endif
|
|
|
|
// Load the shared library referred to by cacheDir and resName. If we have
|
|
// already loaded this library, we instead create a new copy (in the
|
|
// cache dir) and then load that. We then immediately destroy the copy.
|
|
// This is required behavior to implement script instancing for the support
|
|
// library, since shared objects are loaded and de-duped by name only.
|
|
|
|
// For 64bit RS Support Lib, the shared lib path cannot be constructed from
|
|
// cacheDir, so nativeLibDir is needed to load shared libs.
|
|
static void* loadSharedLibrary(const char *cacheDir, const char *resName,
|
|
const char *nativeLibDir = nullptr,
|
|
bool *alreadyLoaded = nullptr);
|
|
|
|
// Load the shared library referred to by fullPath, and delete it right
|
|
// after loading it. Files loaded by this function are only used once, e.g.,
|
|
// shared libraries generated for scripts in a debug context. Deleting them
|
|
// is OK in this case since the shared libraries have already been dlopened.
|
|
// Deletion is also required because such files are not intended for reuse.
|
|
static void* loadAndDeleteSharedLibrary(const char *fullPath);
|
|
|
|
// Create a len length string containing random characters from [A-Za-z0-9].
|
|
static std::string getRandomString(size_t len);
|
|
|
|
private:
|
|
// Attempt to load the shared library from origName, but then fall back to
|
|
// creating a copy of the shared library if necessary (to ensure instancing).
|
|
// This function returns the dlopen()-ed handle if successful.
|
|
static void *loadSOHelper(const char *origName, const char *cacheDir,
|
|
const char *resName, bool* alreadyLoaded = nullptr);
|
|
|
|
static const char* LD_EXE_PATH;
|
|
static const char* RS_CACHE_DIR;
|
|
};
|
|
|
|
class ScriptExecutable {
|
|
public:
|
|
ScriptExecutable(void** fieldAddress, bool* fieldIsObject,
|
|
const char* const * fieldName, size_t varCount,
|
|
InvokeFunc_t* invokeFunctions, size_t funcCount,
|
|
ForEachFunc_t* forEachFunctions, uint32_t* forEachSignatures,
|
|
size_t forEachCount,
|
|
ReduceDescription *reduceDescriptions, size_t reduceCount,
|
|
const char** pragmaKeys, const char** pragmaValues,
|
|
size_t pragmaCount,
|
|
const char **globalNames, const void **globalAddresses,
|
|
const size_t *globalSizes,
|
|
const uint32_t *globalProperties, size_t globalEntries,
|
|
bool isThreadable, uint32_t buildChecksum) :
|
|
mFieldAddress(fieldAddress), mFieldIsObject(fieldIsObject),
|
|
mFieldName(fieldName), mExportedVarCount(varCount),
|
|
mInvokeFunctions(invokeFunctions), mFuncCount(funcCount),
|
|
mForEachFunctions(forEachFunctions), mForEachSignatures(forEachSignatures),
|
|
mForEachCount(forEachCount),
|
|
mReduceDescriptions(reduceDescriptions), mReduceCount(reduceCount),
|
|
mPragmaKeys(pragmaKeys), mPragmaValues(pragmaValues),
|
|
mPragmaCount(pragmaCount), mGlobalNames(globalNames),
|
|
mGlobalAddresses(globalAddresses), mGlobalSizes(globalSizes),
|
|
mGlobalProperties(globalProperties), mGlobalEntries(globalEntries),
|
|
mIsThreadable(isThreadable), mBuildChecksum(buildChecksum) {
|
|
}
|
|
|
|
~ScriptExecutable() {
|
|
for (size_t i = 0; i < mExportedVarCount; ++i) {
|
|
if (mFieldIsObject[i]) {
|
|
if (mFieldAddress[i] != nullptr) {
|
|
rs_object_base *obj_addr =
|
|
reinterpret_cast<rs_object_base *>(mFieldAddress[i]);
|
|
rsrClearObject(obj_addr);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (size_t i = 0; i < mPragmaCount; ++i) {
|
|
delete [] mPragmaKeys[i];
|
|
delete [] mPragmaValues[i];
|
|
}
|
|
delete[] mPragmaValues;
|
|
delete[] mPragmaKeys;
|
|
|
|
delete[] mReduceDescriptions;
|
|
|
|
delete[] mForEachSignatures;
|
|
delete[] mForEachFunctions;
|
|
|
|
delete[] mInvokeFunctions;
|
|
|
|
for (size_t i = 0; i < mExportedVarCount; i++) {
|
|
delete[] mFieldName[i];
|
|
}
|
|
delete[] mFieldName;
|
|
delete[] mFieldIsObject;
|
|
delete[] mFieldAddress;
|
|
}
|
|
|
|
// Create an ScriptExecutable object from a shared object.
|
|
// If expectedChecksum is not zero, it will be compared to the checksum
|
|
// embedded in the shared object. A mismatch will cause a failure.
|
|
// If succeeded, returns the new object. Otherwise, returns nullptr.
|
|
static ScriptExecutable*
|
|
createFromSharedObject(void* sharedObj,
|
|
uint32_t expectedChecksum = 0);
|
|
|
|
size_t getExportedVariableCount() const { return mExportedVarCount; }
|
|
size_t getExportedFunctionCount() const { return mFuncCount; }
|
|
size_t getExportedForEachCount() const { return mForEachCount; }
|
|
size_t getExportedReduceCount() const { return mReduceCount; }
|
|
size_t getPragmaCount() const { return mPragmaCount; }
|
|
|
|
void* getFieldAddress(int slot) const { return mFieldAddress[slot]; }
|
|
void* getFieldAddress(const char* name) const;
|
|
bool getFieldIsObject(int slot) const { return mFieldIsObject[slot]; }
|
|
const char* getFieldName(int slot) const { return mFieldName[slot]; }
|
|
|
|
InvokeFunc_t getInvokeFunction(int slot) const { return mInvokeFunctions[slot]; }
|
|
|
|
ForEachFunc_t getForEachFunction(int slot) const { return mForEachFunctions[slot]; }
|
|
uint32_t getForEachSignature(int slot) const { return mForEachSignatures[slot]; }
|
|
|
|
const ReduceDescription* getReduceDescription(int slot) const {
|
|
return &mReduceDescriptions[slot];
|
|
}
|
|
|
|
const char ** getPragmaKeys() const { return mPragmaKeys; }
|
|
const char ** getPragmaValues() const { return mPragmaValues; }
|
|
|
|
const char* getGlobalName(int i) const {
|
|
if (i < mGlobalEntries) {
|
|
return mGlobalNames[i];
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
const void* getGlobalAddress(int i) const {
|
|
if (i < mGlobalEntries) {
|
|
return mGlobalAddresses[i];
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
size_t getGlobalSize(int i) const {
|
|
if (i < mGlobalEntries) {
|
|
return mGlobalSizes[i];
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
uint32_t getGlobalProperties(int i) const {
|
|
if (i < mGlobalEntries) {
|
|
return mGlobalProperties[i];
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
int getGlobalEntries() const { return mGlobalEntries; }
|
|
|
|
bool getThreadable() const { return mIsThreadable; }
|
|
|
|
uint32_t getBuildChecksum() const { return mBuildChecksum; }
|
|
|
|
bool dumpGlobalInfo() const;
|
|
|
|
private:
|
|
void** mFieldAddress;
|
|
bool* mFieldIsObject;
|
|
const char* const * mFieldName;
|
|
size_t mExportedVarCount;
|
|
|
|
InvokeFunc_t* mInvokeFunctions;
|
|
size_t mFuncCount;
|
|
|
|
ForEachFunc_t* mForEachFunctions;
|
|
uint32_t* mForEachSignatures;
|
|
size_t mForEachCount;
|
|
|
|
ReduceDescription* mReduceDescriptions;
|
|
size_t mReduceCount;
|
|
|
|
const char ** mPragmaKeys;
|
|
const char ** mPragmaValues;
|
|
size_t mPragmaCount;
|
|
|
|
const char ** mGlobalNames;
|
|
const void ** mGlobalAddresses;
|
|
const size_t * mGlobalSizes;
|
|
const uint32_t * mGlobalProperties;
|
|
int mGlobalEntries;
|
|
|
|
bool mIsThreadable;
|
|
uint32_t mBuildChecksum;
|
|
};
|
|
|
|
} // namespace renderscript
|
|
} // namespace android
|
|
|
|
#endif // ANDROID_RENDERSCRIPT_EXECUTABLE_H
|