1/*
2 * Copyright 2012, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17// #define LOG_NDEBUG 0
18#include "bcc/Renderscript/RSInfo.h"
19
20#if !defined(_WIN32)  /* TODO create a HAVE_DLFCN_H */
21#include <dlfcn.h>
22#endif
23
24#include <cstring>
25#include <new>
26#include <string>
27
28#include "bcc/Support/FileBase.h"
29#include "bcc/Support/Log.h"
30
31#ifdef HAVE_ANDROID_OS
32#include <cutils/properties.h>
33#endif
34
35using namespace bcc;
36
37android::String8 RSInfo::GetPath(const char *pFilename) {
38  android::String8 result(pFilename);
39  result.append(".info");
40  return result;
41}
42
43static std::string stringFromSourceHash(const RSInfo::DependencyHashTy& hash) {
44    std::string s;
45    s.reserve(SHA1_DIGEST_LENGTH + 1);
46    for (int i = 0; i < SHA1_DIGEST_LENGTH; i++) {
47        char buf[4];
48        snprintf(buf, sizeof(buf), "%02x", hash[i]);
49        s.append(buf);
50    }
51    return s;
52}
53
54std::string bcc::getCommandLine(int argc, const char* const* argv) {
55    std::string s;
56    for (int i = 0; i < argc; i++) {
57        if (i > 0) {
58            s += ' ';
59        }
60        s += argv[i];
61    }
62    return s;
63}
64
65bool RSInfo::IsConsistent(const char* pInputFilename, const DependencyHashTy& expectedSourceHash,
66                          const char* expectedCompileCommandLine,
67                          const char* expectedBuildFingerprint) {
68    if (::memcmp(mSourceHash, expectedSourceHash, SHA1_DIGEST_LENGTH) != 0) {
69        ALOGD("Cache %s is dirty due to the source it depends on has been changed:",
70              pInputFilename);
71        ALOGD("expected: %s", stringFromSourceHash(expectedSourceHash).c_str());
72        ALOGD("cached  : %s", stringFromSourceHash(mSourceHash).c_str());
73        return false;
74    }
75    if (strcmp(expectedCompileCommandLine, mCompileCommandLine) != 0) {
76        ALOGD("Cache %s is dirty because the command line used to compile it has changed:",
77              pInputFilename);
78        ALOGD("expected: %s", expectedCompileCommandLine);
79        ALOGD("cached  : %s", mCompileCommandLine);
80        return false;
81    }
82    if (strcmp(expectedBuildFingerprint, mBuildFingerprint) != 0) {
83        ALOGD("Cache %s is dirty because the build fingerprint has changed:", pInputFilename);
84        ALOGD("expected: %s", expectedBuildFingerprint);
85        ALOGD("cached  : %s", mBuildFingerprint);
86        return false;
87    }
88    return true;
89}
90
91RSInfo::RSInfo(size_t pStringPoolSize) : mStringPool(NULL) {
92  ::memset(&mHeader, 0, sizeof(mHeader));
93
94  ::memcpy(mHeader.magic, RSINFO_MAGIC, sizeof(mHeader.magic));
95  ::memcpy(mHeader.version, RSINFO_VERSION, sizeof(mHeader.version));
96
97  mHeader.headerSize = sizeof(mHeader);
98
99  mHeader.pragmaList.itemSize = sizeof(rsinfo::PragmaItem);
100  mHeader.objectSlotList.itemSize = sizeof(rsinfo::ObjectSlotItem);
101  mHeader.exportVarNameList.itemSize = sizeof(rsinfo::ExportVarNameItem);
102  mHeader.exportFuncNameList.itemSize = sizeof(rsinfo::ExportFuncNameItem);
103  mHeader.exportForeachFuncList.itemSize = sizeof(rsinfo::ExportForeachFuncItem);
104
105  if (pStringPoolSize > 0) {
106    mHeader.strPoolSize = pStringPoolSize;
107    mStringPool = new (std::nothrow) char [ mHeader.strPoolSize ];
108    if (mStringPool == NULL) {
109      ALOGE("Out of memory when allocate memory for string pool in RSInfo "
110            "constructor (size: %u)!", mHeader.strPoolSize);
111    }
112    ::memset(mStringPool, 0, mHeader.strPoolSize);
113  }
114  mSourceHash = NULL;
115  mCompileCommandLine = NULL;
116  mBuildFingerprint = NULL;
117}
118
119RSInfo::~RSInfo() {
120  delete [] mStringPool;
121}
122
123bool RSInfo::layout(off_t initial_offset) {
124  mHeader.pragmaList.offset = initial_offset +
125                              mHeader.headerSize +
126                              mHeader.strPoolSize;
127  mHeader.pragmaList.count = mPragmas.size();
128
129#define AFTER(_list) ((_list).offset + (_list).itemSize * (_list).count)
130  mHeader.objectSlotList.offset = AFTER(mHeader.pragmaList);
131  mHeader.objectSlotList.count = mObjectSlots.size();
132
133  mHeader.exportVarNameList.offset = AFTER(mHeader.objectSlotList);
134  mHeader.exportVarNameList.count = mExportVarNames.size();
135
136  mHeader.exportFuncNameList.offset = AFTER(mHeader.exportVarNameList);
137  mHeader.exportFuncNameList.count = mExportFuncNames.size();
138
139  mHeader.exportForeachFuncList.offset = AFTER(mHeader.exportFuncNameList);
140  mHeader.exportForeachFuncList.count = mExportForeachFuncs.size();
141#undef AFTER
142
143  return true;
144}
145
146void RSInfo::dump() const {
147  // Hide the codes to save the code size when debugging is disabled.
148#if !LOG_NDEBUG
149
150  // Dump header
151  ALOGV("RSInfo Header:");
152  ALOGV("\tIs threadable: %s", ((mHeader.isThreadable) ? "true" : "false"));
153  ALOGV("\tHeader size: %u", mHeader.headerSize);
154  ALOGV("\tString pool size: %u", mHeader.strPoolSize);
155
156  if (mSourceHash == NULL) {
157      ALOGV("Source hash: NULL!");
158  } else {
159      ALOGV("Source hash: %s", stringFromSourceHash(mSourceHash).c_str());
160  }
161
162  ALOGV("Compile Command Line: ", mCompileCommandLine ? mCompileCommandLine : "(NULL)");
163  ALOGV("mBuildFingerprint: ", mBuildFingerprint ? mBuildFingerprint : "(NULL)");
164
165#define DUMP_LIST_HEADER(_name, _header) do { \
166  ALOGV(_name ":"); \
167  ALOGV("\toffset: %u", (_header).offset);  \
168  ALOGV("\t# of item: %u", (_header).count);  \
169  ALOGV("\tsize of each item: %u", (_header).itemSize); \
170} while (false)
171
172  DUMP_LIST_HEADER("Pragma list", mHeader.pragmaList);
173  for (PragmaListTy::const_iterator pragma_iter = mPragmas.begin(),
174        pragma_end = mPragmas.end(); pragma_iter != pragma_end; pragma_iter++) {
175    ALOGV("\tkey: %s, value: %s", pragma_iter->first, pragma_iter->second);
176  }
177
178  DUMP_LIST_HEADER("RS object slots", mHeader.objectSlotList);
179  for (ObjectSlotListTy::const_iterator slot_iter = mObjectSlots.begin(),
180          slot_end = mObjectSlots.end(); slot_iter != slot_end; slot_iter++) {
181    ALOGV("slot: %u", *slot_iter);
182  }
183
184  DUMP_LIST_HEADER("RS export variables", mHeader.exportVarNameList);
185  for (ExportVarNameListTy::const_iterator var_iter = mExportVarNames.begin(),
186          var_end = mExportVarNames.end(); var_iter != var_end; var_iter++) {
187    ALOGV("name: %s", *var_iter);
188  }
189
190  DUMP_LIST_HEADER("RS export functions", mHeader.exportFuncNameList);
191  for (ExportFuncNameListTy::const_iterator func_iter = mExportFuncNames.begin(),
192        func_end = mExportFuncNames.end(); func_iter != func_end; func_iter++) {
193    ALOGV("name: %s", *func_iter);
194  }
195
196  DUMP_LIST_HEADER("RS foreach list", mHeader.exportForeachFuncList);
197  for (ExportForeachFuncListTy::const_iterator
198          foreach_iter = mExportForeachFuncs.begin(),
199          foreach_end = mExportForeachFuncs.end(); foreach_iter != foreach_end;
200          foreach_iter++) {
201    ALOGV("name: %s, signature: %05x", foreach_iter->first,
202                                       foreach_iter->second);
203  }
204#undef DUMP_LIST_HEADER
205
206#endif // LOG_NDEBUG
207  return;
208}
209
210const char *RSInfo::getStringFromPool(rsinfo::StringIndexTy pStrIdx) const {
211  // String pool uses direct indexing. Ensure that the pStrIdx is within the
212  // range.
213  if (pStrIdx >= mHeader.strPoolSize) {
214    ALOGE("String index #%u is out of range in string pool (size: %u)!",
215          pStrIdx, mHeader.strPoolSize);
216    return NULL;
217  }
218  return &mStringPool[ pStrIdx ];
219}
220
221rsinfo::StringIndexTy RSInfo::getStringIdxInPool(const char *pStr) const {
222  // Assume we are on the flat memory architecture (i.e., the memory space is
223  // continuous.)
224  if ((mStringPool + mHeader.strPoolSize) < pStr) {
225    ALOGE("String %s does not in the string pool!", pStr);
226    return rsinfo::gInvalidStringIndex;
227  }
228  return (pStr - mStringPool);
229}
230
231RSInfo::FloatPrecision RSInfo::getFloatPrecisionRequirement() const {
232  // Check to see if we have any FP precision-related pragmas.
233  std::string relaxed_pragma("rs_fp_relaxed");
234  std::string imprecise_pragma("rs_fp_imprecise");
235  std::string full_pragma("rs_fp_full");
236  bool relaxed_pragma_seen = false;
237  bool full_pragma_seen = false;
238
239  for (PragmaListTy::const_iterator pragma_iter = mPragmas.begin(),
240           pragma_end = mPragmas.end(); pragma_iter != pragma_end;
241       pragma_iter++) {
242    const char *pragma_key = pragma_iter->first;
243    if (!relaxed_pragma.compare(pragma_key)) {
244      relaxed_pragma_seen = true;
245    } else if (!imprecise_pragma.compare(pragma_key)) {
246      ALOGW("rs_fp_imprecise is deprecated.  Assuming rs_fp_relaxed instead.");
247      relaxed_pragma_seen = true;
248    } else if (!full_pragma.compare(pragma_key)) {
249      full_pragma_seen = true;
250    }
251  }
252
253  if (relaxed_pragma_seen && full_pragma_seen) {
254    ALOGE("Full and relaxed precision specified at the same time!");
255  }
256  RSInfo::FloatPrecision result = relaxed_pragma_seen ? FP_Relaxed : FP_Full;
257
258#ifdef HAVE_ANDROID_OS
259  // Provide an override for precsion via adb shell setprop
260  // adb shell setprop debug.rs.precision rs_fp_full
261  // adb shell setprop debug.rs.precision rs_fp_relaxed
262  // adb shell setprop debug.rs.precision rs_fp_imprecise
263  char precision_prop_buf[PROPERTY_VALUE_MAX];
264  property_get("debug.rs.precision", precision_prop_buf, "");
265
266  if (precision_prop_buf[0]) {
267    if (!relaxed_pragma.compare(precision_prop_buf)) {
268      ALOGI("Switching to RS FP relaxed mode via setprop");
269      result = FP_Relaxed;
270    } else if (!imprecise_pragma.compare(precision_prop_buf)) {
271      ALOGW("Switching to RS FP relaxed mode via setprop. rs_fp_imprecise was specified but is "
272              "deprecated ");
273      result = FP_Relaxed;
274    } else if (!full_pragma.compare(precision_prop_buf)) {
275      ALOGI("Switching to RS FP full mode via setprop");
276      result = FP_Full;
277    } else {
278      ALOGE("Unrecognized debug.rs.precision %s", precision_prop_buf);
279    }
280  }
281#endif
282
283  return result;
284}
285