Merge "Add x86 server support." into jb-mr2-dev
diff --git a/cpp/Allocation.cpp b/cpp/Allocation.cpp
index d2d81c9..4368225 100644
--- a/cpp/Allocation.cpp
+++ b/cpp/Allocation.cpp
@@ -145,17 +145,21 @@
}
void Allocation::ioSendOutput() {
+#ifndef RS_COMPATIBILITY_LIB
if ((mUsage & RS_ALLOCATION_USAGE_IO_OUTPUT) == 0) {
ALOGE("Can only send buffer if IO_OUTPUT usage specified.");
}
rsAllocationIoSend(mRS->getContext(), getID());
+#endif
}
void Allocation::ioGetInput() {
+#ifndef RS_COMPATIBILITY_LIB
if ((mUsage & RS_ALLOCATION_USAGE_IO_INPUT) == 0) {
ALOGE("Can only send buffer if IO_OUTPUT usage specified.");
}
rsAllocationIoReceive(mRS->getContext(), getID());
+#endif
}
void Allocation::generateMipmaps() {
diff --git a/cpp/BaseObj.cpp b/cpp/BaseObj.cpp
index d0102d0..828bd87 100644
--- a/cpp/BaseObj.cpp
+++ b/cpp/BaseObj.cpp
@@ -14,8 +14,6 @@
* limitations under the License.
*/
-#define LOG_TAG "libRS_cpp"
-
#include "RenderScript.h"
#include <rs.h>
diff --git a/cpp/Element.cpp b/cpp/Element.cpp
index f3e83d0..51a96cd 100644
--- a/cpp/Element.cpp
+++ b/cpp/Element.cpp
@@ -40,7 +40,7 @@
if (index >= mVisibleElementMap.size()) {
mRS->throwError("Illegal sub-element index");
}
- return mElementNames[mVisibleElementMap[index]];
+ return mElementNames[mVisibleElementMap[index]].string();
}
size_t Element::getSubElementArraySize(uint32_t index) {
@@ -338,7 +338,7 @@
// Skip padding fields after a vector 3 type.
if (mSkipPadding) {
const char *s1 = "#padding_";
- const char *s2 = name;
+ const char *s2 = name.string();
size_t len = strlen(s1);
if (strlen(s2) >= len) {
if (!memcmp(s1, s2, len)) {
diff --git a/cpp/RenderScript.cpp b/cpp/RenderScript.cpp
index 886e1d4..503798b 100644
--- a/cpp/RenderScript.cpp
+++ b/cpp/RenderScript.cpp
@@ -14,15 +14,13 @@
* limitations under the License.
*/
-#define LOG_TAG "libRS_cpp"
-
-#include <utils/Log.h>
#include <malloc.h>
#include <string.h>
#include <pthread.h>
#include "RenderScript.h"
#include "rs.h"
+#include "rsUtils.h"
using namespace android;
using namespace RSC;
diff --git a/cpp/RenderScript.h b/cpp/RenderScript.h
index 9e74922..9a7a565 100644
--- a/cpp/RenderScript.h
+++ b/cpp/RenderScript.h
@@ -20,4 +20,8 @@
#include "rsDefines.h"
#include "rsCppStructs.h"
+#ifdef RS_SERVER
+#define RS_VERSION 18
+#endif
+
#endif
diff --git a/cpp/Script.cpp b/cpp/Script.cpp
index ee03aaf..54a571a 100644
--- a/cpp/Script.cpp
+++ b/cpp/Script.cpp
@@ -14,7 +14,6 @@
* limitations under the License.
*/
-#include <utils/Log.h>
#include <malloc.h>
#include "RenderScript.h"
diff --git a/cpp/ScriptC.cpp b/cpp/ScriptC.cpp
index 95bd9a4..f66e0ec 100644
--- a/cpp/ScriptC.cpp
+++ b/cpp/ScriptC.cpp
@@ -14,7 +14,6 @@
* limitations under the License.
*/
-#include <utils/Log.h>
#include <malloc.h>
#include "RenderScript.h"
diff --git a/cpp/ScriptIntrinsics.cpp b/cpp/ScriptIntrinsics.cpp
index 4a39d0e..44e8760 100644
--- a/cpp/ScriptIntrinsics.cpp
+++ b/cpp/ScriptIntrinsics.cpp
@@ -14,7 +14,6 @@
* limitations under the License.
*/
-#include <utils/Log.h>
#include <malloc.h>
#include "RenderScript.h"
diff --git a/cpp/Type.cpp b/cpp/Type.cpp
index 675f66e..8fa505c 100644
--- a/cpp/Type.cpp
+++ b/cpp/Type.cpp
@@ -14,14 +14,12 @@
* limitations under the License.
*/
-#define LOG_TAG "libRS_cpp"
-
-#include <utils/Log.h>
#include <malloc.h>
#include <string.h>
#include <rs.h>
#include "RenderScript.h"
+#include "rsUtils.h"
using namespace android;
using namespace RSC;
diff --git a/cpp/rsCppStructs.h b/cpp/rsCppStructs.h
index 67df202..97420fb 100644
--- a/cpp/rsCppStructs.h
+++ b/cpp/rsCppStructs.h
@@ -17,9 +17,12 @@
#ifndef ANDROID_RSCPPSTRUCTS_H
#define ANDROID_RSCPPSTRUCTS_H
-#include <utils/String8.h>
-#include <utils/Vector.h>
+#include "rsUtils.h"
+#ifndef RS_SERVER
#include "utils/RefBase.h"
+#else
+#include "RefBase.h"
+#endif
// Every row in an RS allocation is guaranteed to be aligned by this amount
// Every row in a user-backed allocation must be aligned by this amount
diff --git a/cpu_ref/rsCpuCore.cpp b/cpu_ref/rsCpuCore.cpp
index 604f180..7facade 100644
--- a/cpu_ref/rsCpuCore.cpp
+++ b/cpu_ref/rsCpuCore.cpp
@@ -24,10 +24,20 @@
#include <sys/types.h>
#include <sys/resource.h>
#include <sched.h>
-#include <cutils/properties.h>
#include <sys/syscall.h>
#include <string.h>
+
+#ifndef RS_SERVER
+#include <cutils/properties.h>
#include "utils/StopWatch.h"
+#endif
+
+#ifdef RS_SERVER
+// Android exposes gettid(), standard Linux does not
+static pid_t gettid() {
+ return syscall(SYS_gettid);
+}
+#endif
using namespace android;
using namespace android::renderscript;
@@ -102,8 +112,7 @@
void * RsdCpuReferenceImpl::helperThreadProc(void *vrsc) {
RsdCpuReferenceImpl *dc = (RsdCpuReferenceImpl *)vrsc;
-
- uint32_t idx = (uint32_t)android_atomic_inc(&dc->mWorkers.mLaunchCount);
+ uint32_t idx = __sync_fetch_and_add(&dc->mWorkers.mLaunchCount, 1);
//ALOGV("RS helperThread starting %p idx=%i", dc, idx);
@@ -132,7 +141,7 @@
// idx +1 is used because the calling thread is always worker 0.
dc->mWorkers.mLaunchCallback(dc->mWorkers.mLaunchData, idx+1);
}
- android_atomic_dec(&dc->mWorkers.mRunningCount);
+ __sync_fetch_and_sub(&dc->mWorkers.mRunningCount, 1);
dc->mWorkers.mCompleteSignal.set();
}
@@ -153,7 +162,9 @@
return;
}
- android_atomic_release_store(mWorkers.mCount, &mWorkers.mRunningCount);
+ mWorkers.mRunningCount = mWorkers.mCount;
+ __sync_synchronize();
+
for (uint32_t ct = 0; ct < mWorkers.mCount; ct++) {
mWorkers.mLaunchSignals[ct].set();
}
@@ -164,7 +175,7 @@
mWorkers.mLaunchCallback(mWorkers.mLaunchData, 0);
}
- while (android_atomic_acquire_load(&mWorkers.mRunningCount) != 0) {
+ while (__sync_fetch_and_or(&mWorkers.mRunningCount, 0) != 0) {
mWorkers.mCompleteSignal.wait();
}
}
@@ -224,8 +235,9 @@
mWorkers.mCompleteSignal.init();
- android_atomic_release_store(mWorkers.mCount, &mWorkers.mRunningCount);
- android_atomic_release_store(0, &mWorkers.mLaunchCount);
+ mWorkers.mRunningCount = mWorkers.mCount;
+ mWorkers.mLaunchCount = 0;
+ __sync_synchronize();
pthread_attr_t threadAttr;
status = pthread_attr_init(&threadAttr);
@@ -242,7 +254,7 @@
break;
}
}
- while (android_atomic_acquire_load(&mWorkers.mRunningCount) != 0) {
+ while (__sync_fetch_and_or(&mWorkers.mRunningCount, 0) != 0) {
usleep(100);
}
@@ -261,7 +273,8 @@
mExit = true;
mWorkers.mLaunchData = NULL;
mWorkers.mLaunchCallback = NULL;
- android_atomic_release_store(mWorkers.mCount, &mWorkers.mRunningCount);
+ mWorkers.mRunningCount = mWorkers.mCount;
+ __sync_synchronize();
for (uint32_t ct = 0; ct < mWorkers.mCount; ct++) {
mWorkers.mLaunchSignals[ct].set();
}
@@ -269,7 +282,7 @@
for (uint32_t ct = 0; ct < mWorkers.mCount; ct++) {
pthread_join(mWorkers.mThreadId[ct], &res);
}
- rsAssert(android_atomic_acquire_load(&mWorkers.mRunningCount) == 0);
+ rsAssert(__sync_fetch_and_or(&mWorkers.mRunningCount, 0) == 0);
// Global structure cleanup.
lockMutex();
@@ -292,7 +305,7 @@
outer_foreach_t fn = (outer_foreach_t) mtls->kernel;
while (1) {
- uint32_t slice = (uint32_t)android_atomic_inc(&mtls->mSliceNum);
+ uint32_t slice = (uint32_t)__sync_fetch_and_add(&mtls->mSliceNum, 1);
uint32_t yStart = mtls->yStart + slice * mtls->mSliceSize;
uint32_t yEnd = yStart + mtls->mSliceSize;
yEnd = rsMin(yEnd, mtls->yEnd);
@@ -322,7 +335,7 @@
outer_foreach_t fn = (outer_foreach_t) mtls->kernel;
while (1) {
- uint32_t slice = (uint32_t)android_atomic_inc(&mtls->mSliceNum);
+ uint32_t slice = (uint32_t)__sync_fetch_and_add(&mtls->mSliceNum, 1);
uint32_t xStart = mtls->xStart + slice * mtls->mSliceSize;
uint32_t xEnd = xStart + mtls->mSliceSize;
xEnd = rsMin(xEnd, mtls->xEnd);
diff --git a/cpu_ref/rsCpuIntrinsic3DLUT.cpp b/cpu_ref/rsCpuIntrinsic3DLUT.cpp
index 2eca373..03f24d8 100644
--- a/cpu_ref/rsCpuIntrinsic3DLUT.cpp
+++ b/cpu_ref/rsCpuIntrinsic3DLUT.cpp
@@ -135,7 +135,7 @@
uint4 v2 = (v + 0x7f) >> (int4)8;
uchar4 ret = convert_uchar4(v2);
- ret.a = in->a;
+ ret.w = in->w;
#if 0
if (!x1) {
diff --git a/cpu_ref/rsCpuIntrinsicBlend.cpp b/cpu_ref/rsCpuIntrinsicBlend.cpp
index d7b01b6..4e9470e 100644
--- a/cpu_ref/rsCpuIntrinsicBlend.cpp
+++ b/cpu_ref/rsCpuIntrinsicBlend.cpp
@@ -143,7 +143,7 @@
for (;x1 < x2; x1++, out++, in++) {
short4 in_s = convert_short4(*in);
short4 out_s = convert_short4(*out);
- in_s = in_s + ((out_s * (short4)(255 - in_s.a)) >> (short4)8);
+ in_s = in_s + ((out_s * (short4)(255 - in_s.w)) >> (short4)8);
*out = convert_uchar4(in_s);
}
break;
@@ -160,7 +160,7 @@
for (;x1 < x2; x1++, out++, in++) {
short4 in_s = convert_short4(*in);
short4 out_s = convert_short4(*out);
- in_s = out_s + ((in_s * (short4)(255 - out_s.a)) >> (short4)8);
+ in_s = out_s + ((in_s * (short4)(255 - out_s.w)) >> (short4)8);
*out = convert_uchar4(in_s);
}
break;
@@ -176,7 +176,7 @@
#endif
for (;x1 < x2; x1++, out++, in++) {
short4 in_s = convert_short4(*in);
- in_s = (in_s * out->a) >> (short4)8;
+ in_s = (in_s * out->w) >> (short4)8;
*out = convert_uchar4(in_s);
}
break;
@@ -192,7 +192,7 @@
#endif
for (;x1 < x2; x1++, out++, in++) {
short4 out_s = convert_short4(*out);
- out_s = (out_s * in->a) >> (short4)8;
+ out_s = (out_s * in->w) >> (short4)8;
*out = convert_uchar4(out_s);
}
break;
@@ -208,7 +208,7 @@
#endif
for (;x1 < x2; x1++, out++, in++) {
short4 in_s = convert_short4(*in);
- in_s = (in_s * (short4)(255 - out->a)) >> (short4)8;
+ in_s = (in_s * (short4)(255 - out->w)) >> (short4)8;
*out = convert_uchar4(in_s);
}
break;
@@ -224,7 +224,7 @@
#endif
for (;x1 < x2; x1++, out++, in++) {
short4 out_s = convert_short4(*out);
- out_s = (out_s * (short4)(255 - in->a)) >> (short4)8;
+ out_s = (out_s * (short4)(255 - in->w)) >> (short4)8;
*out = convert_uchar4(out_s);
}
break;
@@ -241,8 +241,8 @@
for (;x1 < x2; x1++, out++, in++) {
short4 in_s = convert_short4(*in);
short4 out_s = convert_short4(*out);
- out_s.rgb = ((in_s.rgb * out_s.a) +
- (out_s.rgb * ((short3)255 - (short3)in_s.a))) >> (short3)8;
+ out_s.xyz = ((in_s.xyz * out_s.w) +
+ (out_s.xyz * ((short3)255 - (short3)in_s.w))) >> (short3)8;
*out = convert_uchar4(out_s);
}
break;
@@ -259,8 +259,8 @@
for (;x1 < x2; x1++, out++, in++) {
short4 in_s = convert_short4(*in);
short4 out_s = convert_short4(*out);
- out_s.rgb = ((out_s.rgb * in_s.a) +
- (in_s.rgb * ((short3)255 - (short3)out_s.a))) >> (short3)8;
+ out_s.xyz = ((out_s.xyz * in_s.w) +
+ (in_s.xyz * ((short3)255 - (short3)out_s.w))) >> (short3)8;
*out = convert_uchar4(out_s);
}
break;
@@ -388,12 +388,12 @@
}
#endif
for (;x1 < x2; x1++, out++, in++) {
- uint32_t iR = in->r, iG = in->g, iB = in->b, iA = in->a,
- oR = out->r, oG = out->g, oB = out->b, oA = out->a;
- out->r = (oR + iR) > 255 ? 255 : oR + iR;
- out->g = (oG + iG) > 255 ? 255 : oG + iG;
- out->b = (oB + iB) > 255 ? 255 : oB + iB;
- out->a = (oA + iA) > 255 ? 255 : oA + iA;
+ uint32_t iR = in->x, iG = in->y, iB = in->z, iA = in->w,
+ oR = out->x, oG = out->y, oB = out->z, oA = out->w;
+ out->x = (oR + iR) > 255 ? 255 : oR + iR;
+ out->y = (oG + iG) > 255 ? 255 : oG + iG;
+ out->z = (oB + iB) > 255 ? 255 : oB + iB;
+ out->w = (oA + iA) > 255 ? 255 : oA + iA;
}
break;
case BLEND_SUBTRACT:
@@ -407,12 +407,12 @@
}
#endif
for (;x1 < x2; x1++, out++, in++) {
- int32_t iR = in->r, iG = in->g, iB = in->b, iA = in->a,
- oR = out->r, oG = out->g, oB = out->b, oA = out->a;
- out->r = (oR - iR) < 0 ? 0 : oR - iR;
- out->g = (oG - iG) < 0 ? 0 : oG - iG;
- out->b = (oB - iB) < 0 ? 0 : oB - iB;
- out->a = (oA - iA) < 0 ? 0 : oA - iA;
+ int32_t iR = in->x, iG = in->y, iB = in->z, iA = in->w,
+ oR = out->x, oG = out->y, oB = out->z, oA = out->w;
+ out->x = (oR - iR) < 0 ? 0 : oR - iR;
+ out->y = (oG - iG) < 0 ? 0 : oG - iG;
+ out->z = (oB - iB) < 0 ? 0 : oB - iB;
+ out->w = (oA - iA) < 0 ? 0 : oA - iA;
}
break;
case BLEND_STAMP:
diff --git a/cpu_ref/rsCpuIntrinsicConvolve5x5.cpp b/cpu_ref/rsCpuIntrinsicConvolve5x5.cpp
index bcd5ffd..112f377 100644
--- a/cpu_ref/rsCpuIntrinsicConvolve5x5.cpp
+++ b/cpu_ref/rsCpuIntrinsicConvolve5x5.cpp
@@ -113,7 +113,7 @@
//ALOGE("x %i %i,%i,%i,%i %i,%i,%i,%i", x, o.x, o.y, o.z, o.w, out[0].x, out[0].y, out[0].z, out[0].w);
//}
//o.w = 0xff;
- out->rgba = o.rgba;
+ out->xyzw = o.xyzw;
}
extern "C" void rsdIntrinsicConvolve5x5_K(void *dst, const void *y0, const void *y1,
diff --git a/cpu_ref/rsCpuIntrinsicYuvToRGB.cpp b/cpu_ref/rsCpuIntrinsicYuvToRGB.cpp
index bb8cde1..3a49c0d 100644
--- a/cpu_ref/rsCpuIntrinsicYuvToRGB.cpp
+++ b/cpu_ref/rsCpuIntrinsicYuvToRGB.cpp
@@ -61,30 +61,30 @@
short V = ((short)v) - 128;
short4 p;
- p.r = (Y * 298 + V * 409 + 128) >> 8;
- p.g = (Y * 298 - U * 100 - V * 208 + 128) >> 8;
- p.b = (Y * 298 + U * 516 + 128) >> 8;
- p.a = 255;
- if(p.r < 0) {
- p.r = 0;
+ p.x = (Y * 298 + V * 409 + 128) >> 8;
+ p.y = (Y * 298 - U * 100 - V * 208 + 128) >> 8;
+ p.z = (Y * 298 + U * 516 + 128) >> 8;
+ p.w = 255;
+ if(p.x < 0) {
+ p.x = 0;
}
- if(p.r > 255) {
- p.r = 255;
+ if(p.x > 255) {
+ p.x = 255;
}
- if(p.g < 0) {
- p.g = 0;
+ if(p.y < 0) {
+ p.y = 0;
}
- if(p.g > 255) {
- p.g = 255;
+ if(p.y > 255) {
+ p.y = 255;
}
- if(p.b < 0) {
- p.b = 0;
+ if(p.z < 0) {
+ p.z = 0;
}
- if(p.b > 255) {
- p.b = 255;
+ if(p.z > 255) {
+ p.z = 255;
}
- return (uchar4){p.r, p.g, p.b, p.a};
+ return (uchar4){p.x, p.y, p.z, p.w};
}
diff --git a/cpu_ref/rsCpuRuntimeMath.cpp b/cpu_ref/rsCpuRuntimeMath.cpp
index f66677b..6c02303 100644
--- a/cpu_ref/rsCpuRuntimeMath.cpp
+++ b/cpu_ref/rsCpuRuntimeMath.cpp
@@ -14,7 +14,9 @@
* limitations under the License.
*/
+#ifndef RS_SERVER
#include <cutils/compiler.h>
+#endif
#include "rsContext.h"
#include "rsScriptC.h"
diff --git a/cpu_ref/rsCpuRuntimeStubs.cpp b/cpu_ref/rsCpuRuntimeStubs.cpp
index ceea9c4..7b8d557 100644
--- a/cpu_ref/rsCpuRuntimeStubs.cpp
+++ b/cpu_ref/rsCpuRuntimeStubs.cpp
@@ -21,12 +21,15 @@
#include "rsMatrix2x2.h"
#include "rsRuntime.h"
-#include "utils/Timers.h"
#include "rsCpuCore.h"
#include "rsCpuScript.h"
#include <time.h>
+#ifndef RS_SERVER
+#include "utils/Timers.h"
+#endif
+
using namespace android;
using namespace android::renderscript;
diff --git a/cpu_ref/rsCpuScript.cpp b/cpu_ref/rsCpuScript.cpp
index 2ae4d83..7887474 100644
--- a/cpu_ref/rsCpuScript.cpp
+++ b/cpu_ref/rsCpuScript.cpp
@@ -23,10 +23,11 @@
//#include "rsdAllocation.h"
//#include "rsCpuIntrinsics.h"
-
+#ifndef RS_SERVER
#include "utils/Vector.h"
#include "utils/Timers.h"
#include "utils/StopWatch.h"
+#endif
#ifdef RS_COMPATIBILITY_LIB
#include <dlfcn.h>
@@ -177,10 +178,14 @@
#else
+#ifndef RS_SERVER
String8 scriptSOName(cacheDir);
scriptSOName = scriptSOName.getPathDir();
scriptSOName.appendPath("lib");
scriptSOName.append("/librs.");
+#else
+ String8 scriptSOName("lib");
+#endif
scriptSOName.append(resName);
scriptSOName.append(".so");
diff --git a/cpu_ref/rsCpuScriptGroup.cpp b/cpu_ref/rsCpuScriptGroup.cpp
index d418c22..b3b5bf9 100644
--- a/cpu_ref/rsCpuScriptGroup.cpp
+++ b/cpu_ref/rsCpuScriptGroup.cpp
@@ -18,10 +18,12 @@
#include "rsCpuScript.h"
#include "rsCpuScriptGroup.h"
+#ifndef RS_SERVER
#include <bcc/BCCContext.h>
#include <bcc/Renderscript/RSCompilerDriver.h>
#include <bcc/Renderscript/RSExecutable.h>
#include <bcc/Renderscript/RSInfo.h>
+#endif
#include "rsScript.h"
#include "rsScriptGroup.h"
diff --git a/driver/rsdAllocation.cpp b/driver/rsdAllocation.cpp
index ed27dca..cdcf48f 100644
--- a/driver/rsdAllocation.cpp
+++ b/driver/rsdAllocation.cpp
@@ -14,15 +14,16 @@
* limitations under the License.
*/
-
#include "rsdCore.h"
#include "rsdAllocation.h"
#include "rsAllocation.h"
+#ifndef RS_SERVER
#include "system/window.h"
#include "ui/Rect.h"
#include "ui/GraphicBufferMapper.h"
+#endif
#ifndef RS_COMPATIBILITY_LIB
#include "rsdFrameBufferObj.h"
@@ -36,6 +37,11 @@
#include <GLES/glext.h>
#endif
+#ifdef RS_SERVER
+// server requires malloc.h for memalign
+#include <malloc.h>
+#endif
+
using namespace android;
using namespace android::renderscript;
@@ -241,10 +247,12 @@
#endif
}
+
static size_t DeriveYUVLayout(int yuv, Allocation::Hal::DrvState *state) {
// YUV only supports basic 2d
// so we can stash the plane pointers in the mipmap levels.
size_t uvSize = 0;
+#ifndef RS_SERVER
switch(yuv) {
case HAL_PIXEL_FORMAT_YV12:
state->lod[1].dimX = state->lod[0].dimX / 2;
@@ -275,6 +283,7 @@
default:
rsAssert(0);
}
+#endif
return uvSize;
}
@@ -406,6 +415,7 @@
rsAssert(!"Size mismatch");
}
+#ifndef RS_SERVER
drv->glTarget = GL_NONE;
if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE) {
if (alloc->mHal.state.hasFaces) {
@@ -418,6 +428,7 @@
drv->glTarget = GL_ARRAY_BUFFER;
}
}
+#endif
#ifndef RS_COMPATIBILITY_LIB
drv->glType = rsdTypeToGLType(alloc->mHal.state.type->getElement()->getComponent().getType());
diff --git a/driver/rsdAllocation.h b/driver/rsdAllocation.h
index d8f46c5..c209203 100644
--- a/driver/rsdAllocation.h
+++ b/driver/rsdAllocation.h
@@ -22,11 +22,13 @@
#include <rsAllocation.h>
#include "../cpu_ref/rsd_cpu.h"
+
+#ifndef RS_SERVER
#include "gui/CpuConsumer.h"
#include "gui/GLConsumer.h"
-
#include <GLES/gl.h>
#include <GLES2/gl2.h>
+#endif
class RsdFrameBufferObj;
struct ANativeWindow;
@@ -65,8 +67,10 @@
ANativeWindow *wnd;
ANativeWindowBuffer *wndBuffer;
+#ifndef RS_SERVER
android::sp< android::CpuConsumer > cpuConsumer;
android::CpuConsumer::LockedBuffer lb;
+#endif
};
#ifndef RS_COMPATIBILITY_LIB
diff --git a/driver/rsdBcc.cpp b/driver/rsdBcc.cpp
index 436b9b2..77e0576 100644
--- a/driver/rsdBcc.cpp
+++ b/driver/rsdBcc.cpp
@@ -25,9 +25,11 @@
#include "rsElement.h"
#include "rsScriptC.h"
+#ifndef RS_SERVER
#include "utils/Vector.h"
#include "utils/Timers.h"
#include "utils/StopWatch.h"
+#endif
using namespace android;
using namespace android::renderscript;
diff --git a/driver/rsdCore.cpp b/driver/rsdCore.cpp
index 367a50b..9e55524 100644
--- a/driver/rsdCore.cpp
+++ b/driver/rsdCore.cpp
@@ -38,10 +38,13 @@
#include <sys/types.h>
#include <sys/resource.h>
#include <sched.h>
-#include <cutils/properties.h>
#include <sys/syscall.h>
#include <string.h>
+#ifndef RS_SERVER
+#include <cutils/properties.h>
+#endif
+
using namespace android;
using namespace android::renderscript;
diff --git a/driver/rsdRuntimeStubs.cpp b/driver/rsdRuntimeStubs.cpp
index 92af7ce..8e7d9ee 100644
--- a/driver/rsdRuntimeStubs.cpp
+++ b/driver/rsdRuntimeStubs.cpp
@@ -21,7 +21,6 @@
#include "rsMatrix2x2.h"
#include "rsRuntime.h"
-#include "utils/Timers.h"
#include "rsdCore.h"
#include "rsdBcc.h"
@@ -69,7 +68,9 @@
typedef uint8_t uchar;
typedef uint16_t ushort;
typedef uint32_t uint;
+#ifndef RS_SERVER
typedef uint64_t ulong;
+#endif
//////////////////////////////////////////////////////////////////////////////
// Allocation
@@ -1050,8 +1051,10 @@
{ "_Z20rsgAllocationSyncAll13rs_allocationj", (void *)&SC_AllocationSyncAll2, false },
{ "_Z20rsgAllocationSyncAll13rs_allocation24rs_allocation_usage_type", (void *)&SC_AllocationSyncAll2, false },
{ "_Z15rsGetAllocationPKv", (void *)&SC_GetAllocation, true },
+#ifndef RS_COMPATIBILITY_LIB
{ "_Z18rsAllocationIoSend13rs_allocation", (void *)&SC_AllocationIoSend, false },
{ "_Z21rsAllocationIoReceive13rs_allocation", (void *)&SC_AllocationIoReceive, false },
+#endif
{ "_Z23rsAllocationCopy1DRange13rs_allocationjjjS_jj", (void *)&SC_AllocationCopy1DRange, false },
{ "_Z23rsAllocationCopy2DRange13rs_allocationjjj26rs_allocation_cubemap_facejjS_jjjS0_", (void *)&SC_AllocationCopy2DRange, false },
@@ -1061,7 +1064,7 @@
{ "_Z14rsSendToClientiPKvj", (void *)&SC_ToClient2, false },
{ "_Z22rsSendToClientBlockingi", (void *)&SC_ToClientBlocking, false },
{ "_Z22rsSendToClientBlockingiPKvj", (void *)&SC_ToClientBlocking2, false },
-
+#ifndef RS_COMPATIBILITY_LIB
{ "_Z22rsgBindProgramFragment19rs_program_fragment", (void *)&SC_BindProgramFragment, false },
{ "_Z19rsgBindProgramStore16rs_program_store", (void *)&SC_BindProgramStore, false },
{ "_Z20rsgBindProgramVertex17rs_program_vertex", (void *)&SC_BindProgramVertex, false },
@@ -1111,6 +1114,7 @@
{ "_Z19rsgClearColorTargetj", (void *)&SC_ClearFrameBufferObjectColorTarget, false },
{ "_Z19rsgClearDepthTargetv", (void *)&SC_ClearFrameBufferObjectDepthTarget, false },
{ "_Z24rsgClearAllRenderTargetsv", (void *)&SC_ClearFrameBufferObjectTargets, false },
+#endif // RS_COMPATIBILITY_LIB
{ "_Z9rsForEach9rs_script13rs_allocationS0_", (void *)&SC_ForEach_SAA, true },
{ "_Z9rsForEach9rs_script13rs_allocationS0_PKv", (void *)&SC_ForEach_SAAU, true },
@@ -1126,12 +1130,346 @@
{ "_Z7rsGetDtv", (void*)&SC_GetDt, false },
// misc
+#ifndef RS_COMPATIBILITY_LIB
{ "_Z5colorffff", (void *)&SC_Color, false },
{ "_Z9rsgFinishv", (void *)&SC_Finish, false },
+#endif
{ NULL, NULL, false }
};
+#ifdef RS_COMPATIBILITY_LIB
+
+uint32_t rsSendToClientBlocking(int cmdID) {
+ Context *rsc = RsdCpuReference::getTlsContext();
+ return rsrToClientBlocking(rsc, cmdID, NULL, 0);
+}
+
+static void SC_debugF(const char *s, float f) {
+ ALOGD("%s %f, 0x%08x", s, f, *((int *) (&f)));
+}
+static void SC_debugFv2(const char *s, float f1, float f2) {
+ ALOGD("%s {%f, %f}", s, f1, f2);
+}
+static void SC_debugFv3(const char *s, float f1, float f2, float f3) {
+ ALOGD("%s {%f, %f, %f}", s, f1, f2, f3);
+}
+static void SC_debugFv4(const char *s, float f1, float f2, float f3, float f4) {
+ ALOGD("%s {%f, %f, %f, %f}", s, f1, f2, f3, f4);
+}
+static void SC_debugF2(const char *s, float2 f) {
+ ALOGD("%s {%f, %f}", s, f.x, f.y);
+}
+static void SC_debugF3(const char *s, float3 f) {
+ ALOGD("%s {%f, %f, %f}", s, f.x, f.y, f.z);
+}
+static void SC_debugF4(const char *s, float4 f) {
+ ALOGD("%s {%f, %f, %f, %f}", s, f.x, f.y, f.z, f.w);
+}
+static void SC_debugD(const char *s, double d) {
+ ALOGD("%s %f, 0x%08llx", s, d, *((long long *) (&d)));
+}
+static void SC_debugFM4v4(const char *s, const float *f) {
+ ALOGD("%s {%f, %f, %f, %f", s, f[0], f[4], f[8], f[12]);
+ ALOGD("%s %f, %f, %f, %f", s, f[1], f[5], f[9], f[13]);
+ ALOGD("%s %f, %f, %f, %f", s, f[2], f[6], f[10], f[14]);
+ ALOGD("%s %f, %f, %f, %f}", s, f[3], f[7], f[11], f[15]);
+}
+static void SC_debugFM3v3(const char *s, const float *f) {
+ ALOGD("%s {%f, %f, %f", s, f[0], f[3], f[6]);
+ ALOGD("%s %f, %f, %f", s, f[1], f[4], f[7]);
+ ALOGD("%s %f, %f, %f}",s, f[2], f[5], f[8]);
+}
+static void SC_debugFM2v2(const char *s, const float *f) {
+ ALOGD("%s {%f, %f", s, f[0], f[2]);
+ ALOGD("%s %f, %f}",s, f[1], f[3]);
+}
+static void SC_debugI8(const char *s, char c) {
+ ALOGD("%s %hhd 0x%hhx", s, c, (unsigned char)c);
+}
+static void SC_debugC2(const char *s, char2 c) {
+ ALOGD("%s {%hhd, %hhd} 0x%hhx 0x%hhx", s, c.x, c.y, (unsigned char)c.x, (unsigned char)c.y);
+}
+static void SC_debugC3(const char *s, char3 c) {
+ ALOGD("%s {%hhd, %hhd, %hhd} 0x%hhx 0x%hhx 0x%hhx", s, c.x, c.y, c.z, (unsigned char)c.x, (unsigned char)c.y, (unsigned char)c.z);
+}
+static void SC_debugC4(const char *s, char4 c) {
+ ALOGD("%s {%hhd, %hhd, %hhd, %hhd} 0x%hhx 0x%hhx 0x%hhx 0x%hhx", s, c.x, c.y, c.z, c.w, (unsigned char)c.x, (unsigned char)c.y, (unsigned char)c.z, (unsigned char)c.w);
+}
+static void SC_debugU8(const char *s, unsigned char c) {
+ ALOGD("%s %hhu 0x%hhx", s, c, c);
+}
+static void SC_debugUC2(const char *s, uchar2 c) {
+ ALOGD("%s {%hhu, %hhu} 0x%hhx 0x%hhx", s, c.x, c.y, c.x, c.y);
+}
+static void SC_debugUC3(const char *s, uchar3 c) {
+ ALOGD("%s {%hhu, %hhu, %hhu} 0x%hhx 0x%hhx 0x%hhx", s, c.x, c.y, c.z, c.x, c.y, c.z);
+}
+static void SC_debugUC4(const char *s, uchar4 c) {
+ ALOGD("%s {%hhu, %hhu, %hhu, %hhu} 0x%hhx 0x%hhx 0x%hhx 0x%hhx", s, c.x, c.y, c.z, c.w, c.x, c.y, c.z, c.w);
+}
+static void SC_debugI16(const char *s, short c) {
+ ALOGD("%s %hd 0x%hx", s, c, c);
+}
+static void SC_debugS2(const char *s, short2 c) {
+ ALOGD("%s {%hd, %hd} 0x%hx 0x%hx", s, c.x, c.y, c.x, c.y);
+}
+static void SC_debugS3(const char *s, short3 c) {
+ ALOGD("%s {%hd, %hd, %hd} 0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.x, c.y, c.z);
+}
+static void SC_debugS4(const char *s, short4 c) {
+ ALOGD("%s {%hd, %hd, %hd, %hd} 0x%hx 0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.w, c.x, c.y, c.z, c.w);
+}
+static void SC_debugU16(const char *s, unsigned short c) {
+ ALOGD("%s %hu 0x%hx", s, c, c);
+}
+static void SC_debugUS2(const char *s, ushort2 c) {
+ ALOGD("%s {%hu, %hu} 0x%hx 0x%hx", s, c.x, c.y, c.x, c.y);
+}
+static void SC_debugUS3(const char *s, ushort3 c) {
+ ALOGD("%s {%hu, %hu, %hu} 0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.x, c.y, c.z);
+}
+static void SC_debugUS4(const char *s, ushort4 c) {
+ ALOGD("%s {%hu, %hu, %hu, %hu} 0x%hx 0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.w, c.x, c.y, c.z, c.w);
+}
+static void SC_debugI32(const char *s, int32_t i) {
+ ALOGD("%s %d 0x%x", s, i, i);
+}
+static void SC_debugI2(const char *s, int2 i) {
+ ALOGD("%s {%d, %d} 0x%x 0x%x", s, i.x, i.y, i.x, i.y);
+}
+static void SC_debugI3(const char *s, int3 i) {
+ ALOGD("%s {%d, %d, %d} 0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.x, i.y, i.z);
+}
+static void SC_debugI4(const char *s, int4 i) {
+ ALOGD("%s {%d, %d, %d, %d} 0x%x 0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.w, i.x, i.y, i.z, i.w);
+}
+static void SC_debugU32(const char *s, uint32_t i) {
+ ALOGD("%s %u 0x%x", s, i, i);
+}
+static void SC_debugUI2(const char *s, uint2 i) {
+ ALOGD("%s {%u, %u} 0x%x 0x%x", s, i.x, i.y, i.x, i.y);
+}
+static void SC_debugUI3(const char *s, uint3 i) {
+ ALOGD("%s {%u, %u, %u} 0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.x, i.y, i.z);
+}
+static void SC_debugUI4(const char *s, uint4 i) {
+ ALOGD("%s {%u, %u, %u, %u} 0x%x 0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.w, i.x, i.y, i.z, i.w);
+}
+static void SC_debugLL64(const char *s, long long ll) {
+ ALOGD("%s %lld 0x%llx", s, ll, ll);
+}
+static void SC_debugL2(const char *s, long2 ll) {
+ ALOGD("%s {%lld, %lld} 0x%llx 0x%llx", s, ll.x, ll.y, ll.x, ll.y);
+}
+static void SC_debugL3(const char *s, long3 ll) {
+ ALOGD("%s {%lld, %lld, %lld} 0x%llx 0x%llx 0x%llx", s, ll.x, ll.y, ll.z, ll.x, ll.y, ll.z);
+}
+static void SC_debugL4(const char *s, long4 ll) {
+ ALOGD("%s {%lld, %lld, %lld, %lld} 0x%llx 0x%llx 0x%llx 0x%llx", s, ll.x, ll.y, ll.z, ll.w, ll.x, ll.y, ll.z, ll.w);
+}
+static void SC_debugULL64(const char *s, unsigned long long ll) {
+ ALOGD("%s %llu 0x%llx", s, ll, ll);
+}
+static void SC_debugUL2(const char *s, ulong2 ll) {
+ ALOGD("%s {%llu, %llu} 0x%llx 0x%llx", s, ll.x, ll.y, ll.x, ll.y);
+}
+static void SC_debugUL3(const char *s, ulong3 ll) {
+ ALOGD("%s {%llu, %llu, %llu} 0x%llx 0x%llx 0x%llx", s, ll.x, ll.y, ll.z, ll.x, ll.y, ll.z);
+}
+static void SC_debugUL4(const char *s, ulong4 ll) {
+ ALOGD("%s {%llu, %llu, %llu, %llu} 0x%llx 0x%llx 0x%llx 0x%llx", s, ll.x, ll.y, ll.z, ll.w, ll.x, ll.y, ll.z, ll.w);
+}
+static void SC_debugP(const char *s, const void *p) {
+ ALOGD("%s %p", s, p);
+}
+
+// TODO: allocation ops, messaging, time
+
+void rsDebug(const char *s, float f) {
+ SC_debugF(s, f);
+}
+
+void rsDebug(const char *s, float f1, float f2) {
+ SC_debugFv2(s, f1, f2);
+}
+
+void rsDebug(const char *s, float f1, float f2, float f3) {
+ SC_debugFv3(s, f1, f2, f3);
+}
+
+void rsDebug(const char *s, float f1, float f2, float f3, float f4) {
+ SC_debugFv4(s, f1, f2, f3, f4);
+}
+
+void rsDebug(const char *s, float2 f) {
+ SC_debugF2(s, f);
+}
+
+void rsDebug(const char *s, float3 f) {
+ SC_debugF3(s, f);
+}
+
+void rsDebug(const char *s, float4 f) {
+ SC_debugF4(s, f);
+}
+
+void rsDebug(const char *s, double d) {
+ SC_debugD(s, d);
+}
+
+void rsDebug(const char *s, rs_matrix4x4 *m) {
+ SC_debugFM4v4(s, (float *) m);
+}
+
+void rsDebug(const char *s, rs_matrix3x3 *m) {
+ SC_debugFM4v4(s, (float *) m);
+}
+
+void rsDebug(const char *s, rs_matrix2x2 *m) {
+ SC_debugFM4v4(s, (float *) m);
+}
+
+void rsDebug(const char *s, char c) {
+ SC_debugI8(s, c);
+}
+
+void rsDebug(const char *s, char2 c) {
+ SC_debugC2(s, c);
+}
+
+void rsDebug(const char *s, char3 c) {
+ SC_debugC3(s, c);
+}
+
+void rsDebug(const char *s, char4 c) {
+ SC_debugC4(s, c);
+}
+
+void rsDebug(const char *s, unsigned char c) {
+ SC_debugU8(s, c);
+}
+
+void rsDebug(const char *s, uchar2 c) {
+ SC_debugUC2(s, c);
+}
+
+void rsDebug(const char *s, uchar3 c) {
+ SC_debugUC3(s, c);
+}
+
+void rsDebug(const char *s, uchar4 c) {
+ SC_debugUC4(s, c);
+}
+
+void rsDebug(const char *s, short c) {
+ SC_debugI16(s, c);
+}
+
+void rsDebug(const char *s, short2 c) {
+ SC_debugS2(s, c);
+}
+
+void rsDebug(const char *s, short3 c) {
+ SC_debugS3(s, c);
+}
+
+void rsDebug(const char *s, short4 c) {
+ SC_debugS4(s, c);
+}
+
+void rsDebug(const char *s, unsigned short c) {
+ SC_debugU16(s, c);
+}
+
+void rsDebug(const char *s, ushort2 c) {
+ SC_debugUS2(s, c);
+}
+
+void rsDebug(const char *s, ushort3 c) {
+ SC_debugUS3(s, c);
+}
+
+void rsDebug(const char *s, ushort4 c) {
+ SC_debugUS4(s, c);
+}
+
+void rsDebug(const char *s, int c) {
+ SC_debugI32(s, c);
+}
+
+void rsDebug(const char *s, int2 c) {
+ SC_debugI2(s, c);
+}
+
+void rsDebug(const char *s, int3 c) {
+ SC_debugI3(s, c);
+}
+
+void rsDebug(const char *s, int4 c) {
+ SC_debugI4(s, c);
+}
+
+void rsDebug(const char *s, unsigned int c) {
+ SC_debugU32(s, c);
+}
+
+void rsDebug(const char *s, uint2 c) {
+ SC_debugUI2(s, c);
+}
+
+void rsDebug(const char *s, uint3 c) {
+ SC_debugUI3(s, c);
+}
+
+void rsDebug(const char *s, uint4 c) {
+ SC_debugUI4(s, c);
+}
+
+void rsDebug(const char *s, long c) {
+ SC_debugLL64(s, c);
+}
+
+void rsDebug(const char *s, long long c) {
+ SC_debugLL64(s, c);
+}
+
+void rsDebug(const char *s, long2 c) {
+ SC_debugL2(s, c);
+}
+
+void rsDebug(const char *s, long3 c) {
+ SC_debugL3(s, c);
+}
+
+void rsDebug(const char *s, long4 c) {
+ SC_debugL4(s, c);
+}
+
+void rsDebug(const char *s, unsigned long c) {
+ SC_debugULL64(s, c);
+}
+
+void rsDebug(const char *s, unsigned long long c) {
+ SC_debugULL64(s, c);
+}
+
+void rsDebug(const char *s, ulong2 c) {
+ SC_debugUL2(s, c);
+}
+
+void rsDebug(const char *s, ulong3 c) {
+ SC_debugUL3(s, c);
+}
+
+void rsDebug(const char *s, ulong4 c) {
+ SC_debugUL4(s, c);
+}
+
+void rsDebug(const char *s, const void *p) {
+ SC_debugP(s, p);
+}
+#endif // RS_COMPATIBILITY_LIB
extern const RsdCpuReference::CpuSymbol * rsdLookupRuntimeStub(Context * pContext, char const* name) {
ScriptC *s = (ScriptC *)pContext;
diff --git a/driver/rsdShaderCache.h b/driver/rsdShaderCache.h
index 88aa32d..1ac1aa1 100644
--- a/driver/rsdShaderCache.h
+++ b/driver/rsdShaderCache.h
@@ -25,8 +25,12 @@
}
}
+#ifndef RS_SERVER
#include <utils/String8.h>
#include <utils/Vector.h>
+#else
+#include "rsUtils.h"
+#endif
class RsdShader;
// ---------------------------------------------------------------------------
diff --git a/driver/rsdVertexArray.h b/driver/rsdVertexArray.h
index 3e807a3..9c655df 100644
--- a/driver/rsdVertexArray.h
+++ b/driver/rsdVertexArray.h
@@ -17,6 +17,8 @@
#ifndef ANDROID_RSD_VERTEX_ARRAY_H
#define ANDROID_RSD_VERTEX_ARRAY_H
+#include "rsUtils.h"
+
namespace android {
namespace renderscript {
@@ -25,8 +27,6 @@
}
}
-#include <utils/String8.h>
-
// An element is a group of Components that occupies one cell in a structure.
class RsdVertexArray {
public:
diff --git a/rsAllocation.cpp b/rsAllocation.cpp
index 7c7bc40..30176ec 100644
--- a/rsAllocation.cpp
+++ b/rsAllocation.cpp
@@ -19,8 +19,10 @@
#include "rsAdapter.h"
#include "rs_hal.h"
+#ifndef RS_SERVER
#include "system/window.h"
#include "gui/GLConsumer.h"
+#endif
using namespace android;
using namespace android::renderscript;
diff --git a/rsComponent.h b/rsComponent.h
index a2e8c0f..4d11718 100644
--- a/rsComponent.h
+++ b/rsComponent.h
@@ -19,7 +19,7 @@
#include "rsUtils.h"
#include "rsDefines.h"
-
+#include "rsStream.h"
// ---------------------------------------------------------------------------
namespace android {
namespace renderscript {
diff --git a/rsContext.cpp b/rsContext.cpp
index 8d972a2..eec2dcd 100644
--- a/rsContext.cpp
+++ b/rsContext.cpp
@@ -29,12 +29,21 @@
#include <sys/resource.h>
#include <sched.h>
-#include <cutils/properties.h>
-
#include <sys/syscall.h>
#include <string.h>
#include <dlfcn.h>
+#ifndef RS_SERVER
+#include <cutils/properties.h>
+#endif
+
+#ifdef RS_SERVER
+// Android exposes gettid(), standard Linux does not
+static pid_t gettid() {
+ return syscall(SYS_gettid);
+}
+#endif
+
using namespace android;
using namespace android::renderscript;
@@ -194,9 +203,13 @@
#endif
static uint32_t getProp(const char *str) {
+#ifndef RS_SERVER
char buf[PROPERTY_VALUE_MAX];
property_get(str, buf, "0");
return atoi(buf);
+#else
+ return 0;
+#endif
}
void Context::displayDebugStats() {
diff --git a/rsFifoSocket.cpp b/rsFifoSocket.cpp
index 44379b2..c10ec4f 100644
--- a/rsFifoSocket.cpp
+++ b/rsFifoSocket.cpp
@@ -15,8 +15,6 @@
*/
#include "rsFifoSocket.h"
-#include "utils/Timers.h"
-#include "utils/StopWatch.h"
#include <stdio.h>
#include <stdlib.h>
@@ -26,6 +24,11 @@
#include <sys/types.h>
#include <sys/socket.h>
+#ifndef RS_SERVER
+#include "utils/Timers.h"
+#include "utils/StopWatch.h"
+#endif
+
using namespace android;
using namespace android::renderscript;
diff --git a/rsObjectBase.cpp b/rsObjectBase.cpp
index 162f162..b66bb73 100644
--- a/rsObjectBase.cpp
+++ b/rsObjectBase.cpp
@@ -69,12 +69,12 @@
}
void ObjectBase::incUserRef() const {
- android_atomic_inc(&mUserRefCount);
+ __sync_fetch_and_add(&mUserRefCount, 1);
//ALOGV("ObjectBase %p incU ref %i, %i", this, mUserRefCount, mSysRefCount);
}
void ObjectBase::incSysRef() const {
- android_atomic_inc(&mSysRefCount);
+ __sync_fetch_and_add(&mSysRefCount, 1);
//ALOGV("ObjectBase %p incS ref %i, %i", this, mUserRefCount, mSysRefCount);
}
@@ -118,18 +118,23 @@
#endif
- if ((android_atomic_dec(&mUserRefCount) <= 1) &&
- (android_atomic_acquire_load(&mSysRefCount) <= 0)) {
- return checkDelete(this);
+ if ((__sync_fetch_and_sub(&mUserRefCount, 1) <= 1)) {
+ __sync_synchronize();
+ if (mSysRefCount <= 0) {
+ return checkDelete(this);
+ }
}
return false;
}
bool ObjectBase::zeroUserRef() const {
//ALOGV("ObjectBase %p zeroU ref %i, %i", this, mUserRefCount, mSysRefCount);
- android_atomic_acquire_store(0, &mUserRefCount);
- if (android_atomic_acquire_load(&mSysRefCount) <= 0) {
- return checkDelete(this);
+ __sync_and_and_fetch(&mUserRefCount, 0);
+ if ((__sync_fetch_and_sub(&mUserRefCount, 1) <= 1)) {
+ __sync_synchronize();
+ if (mSysRefCount <= 0) {
+ return checkDelete(this);
+ }
}
return false;
}
@@ -137,9 +142,11 @@
bool ObjectBase::decSysRef() const {
//ALOGV("ObjectBase %p decS ref %i, %i", this, mUserRefCount, mSysRefCount);
rsAssert(mSysRefCount > 0);
- if ((android_atomic_dec(&mSysRefCount) <= 1) &&
- (android_atomic_acquire_load(&mUserRefCount) <= 0)) {
- return checkDelete(this);
+ if ((__sync_fetch_and_sub(&mSysRefCount, 1) <= 1)) {
+ __sync_synchronize();
+ if (mUserRefCount <= 0) {
+ return checkDelete(this);
+ }
}
return false;
}
diff --git a/rsObjectBase.h b/rsObjectBase.h
index f16acd9..a111e0c 100644
--- a/rsObjectBase.h
+++ b/rsObjectBase.h
@@ -22,7 +22,9 @@
#define RS_OBJECT_DEBUG 0
+#ifndef RS_SERVER
#include <utils/CallStack.h>
+#endif
namespace android {
namespace renderscript {
diff --git a/rsRuntime.h b/rsRuntime.h
index 390338b..d55042c 100644
--- a/rsRuntime.h
+++ b/rsRuntime.h
@@ -17,7 +17,9 @@
#include "rsContext.h"
#include "rsScriptC.h"
+#ifndef RS_SERVER
#include "utils/Timers.h"
+#endif
#include <time.h>
diff --git a/rsScriptC.cpp b/rsScriptC.cpp
index 757d3ca..56c9f06 100644
--- a/rsScriptC.cpp
+++ b/rsScriptC.cpp
@@ -16,8 +16,6 @@
#include "rsContext.h"
#include "rsScriptC.h"
-#include "utils/Timers.h"
-#include "utils/StopWatch.h"
#ifndef RS_COMPATIBILITY_LIB
#ifndef ANDROID_RS_SERIALIZE
@@ -26,6 +24,11 @@
#endif
#endif
+#ifndef RS_SERVER
+#include "utils/Timers.h"
+#include "utils/StopWatch.h"
+#endif
+
#include <sys/stat.h>
using namespace android;
@@ -99,8 +102,10 @@
#endif
void ScriptC::setupScript(Context *rsc) {
+#ifndef RS_SERVER
mEnviroment.mStartTimeMillis
= nanoseconds_to_milliseconds(systemTime(SYSTEM_TIME_MONOTONIC));
+#endif
for (uint32_t ct=0; ct < mHal.info.exportedVariableCount; ct++) {
if (mSlots[ct].get() && !mTypes[ct].get()) {
diff --git a/rsScriptC_Lib.cpp b/rsScriptC_Lib.cpp
index a8591f5..cd5cc3b 100644
--- a/rsScriptC_Lib.cpp
+++ b/rsScriptC_Lib.cpp
@@ -21,7 +21,9 @@
#include "rsMatrix2x2.h"
#include "rsgApiStructs.h"
+#ifndef RS_SERVER
#include "utils/Timers.h"
+#endif
#include <time.h>
@@ -103,17 +105,29 @@
}
int64_t rsrUptimeMillis(Context *rsc) {
+#ifndef RS_SERVER
return nanoseconds_to_milliseconds(systemTime(SYSTEM_TIME_MONOTONIC));
+#else
+ return 0;
+#endif
}
int64_t rsrUptimeNanos(Context *rsc) {
+#ifndef RS_SERVER
return systemTime(SYSTEM_TIME_MONOTONIC);
+#else
+ return 0;
+#endif
}
float rsrGetDt(Context *rsc, const Script *sc) {
+#ifndef RS_SERVER
int64_t l = sc->mEnviroment.mLastDtTime;
sc->mEnviroment.mLastDtTime = systemTime(SYSTEM_TIME_MONOTONIC);
return ((float)(sc->mEnviroment.mLastDtTime - l)) / 1.0e9;
+#else
+ return 0.f;
+#endif
}
//////////////////////////////////////////////////////////////////////////////
diff --git a/rsScriptGroup.cpp b/rsScriptGroup.cpp
index 9230485..f157fee 100644
--- a/rsScriptGroup.cpp
+++ b/rsScriptGroup.cpp
@@ -78,6 +78,7 @@
return ret;
}
+#ifndef RS_SERVER
static int CompareNodeForSort(ScriptGroup::Node *const* lhs,
ScriptGroup::Node *const* rhs) {
if (lhs[0]->mOrder > rhs[0]->mOrder) {
@@ -85,7 +86,18 @@
}
return 0;
}
-
+#else
+class NodeCompare {
+public:
+ bool operator() (const ScriptGroup::Node* lhs,
+ const ScriptGroup::Node* rhs) {
+ if (lhs->mOrder > rhs->mOrder) {
+ return true;
+ }
+ return false;
+ }
+};
+#endif
bool ScriptGroup::calcOrder() {
// Make nodes
@@ -169,7 +181,11 @@
}
// sort
+#ifndef RS_SERVER
mNodes.sort(&CompareNodeForSort);
+#else
+ std::sort(mNodes.begin(), mNodes.end(), NodeCompare());
+#endif
return ret;
}
diff --git a/rsSignal.cpp b/rsSignal.cpp
index 3f6a13c..c59b39e 100644
--- a/rsSignal.cpp
+++ b/rsSignal.cpp
@@ -95,9 +95,11 @@
mSet = false;
ret = true;
} else {
+#ifndef RS_SERVER
if (status != ETIMEDOUT) {
ALOGE("LocklessCommandFifo: error %i waiting for condition.", status);
}
+#endif
}
status = pthread_mutex_unlock(&mMutex);
diff --git a/rsStream.h b/rsStream.h
index 62bcf94..8a192e6 100644
--- a/rsStream.h
+++ b/rsStream.h
@@ -17,8 +17,8 @@
#ifndef ANDROID_RS_STREAM_H
#define ANDROID_RS_STREAM_H
-#include <utils/String8.h>
#include <stdio.h>
+#include "rsUtils.h"
// ---------------------------------------------------------------------------
namespace android {
diff --git a/rsType.cpp b/rsType.cpp
index 74a1a54..dacf5e0 100644
--- a/rsType.cpp
+++ b/rsType.cpp
@@ -16,7 +16,9 @@
#include "rsContext.h"
+#ifndef RS_SERVER
#include "system/graphics.h"
+#endif
using namespace android;
using namespace android::renderscript;
@@ -108,7 +110,7 @@
if (mHal.state.faces) {
offset *= 6;
}
-
+#ifndef RS_SERVER
// YUV only supports basic 2d
// so we can stash the plane pointers in the mipmap levels.
if (mHal.state.dimYuv) {
@@ -133,7 +135,7 @@
rsAssert(0);
}
}
-
+#endif
mTotalSizeBytes = offset;
mHal.state.element = mElement.get();
}
diff --git a/rsUtils.h b/rsUtils.h
index 78341d7..3ef6b5a 100644
--- a/rsUtils.h
+++ b/rsUtils.h
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2009 The Android Open Source Project
+ * Copyright (C) 2013 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.
@@ -20,20 +20,112 @@
#define LOG_NDEBUG 0
#define LOG_TAG "RenderScript"
+#ifndef RS_SERVER
#include <utils/Log.h>
-
-#include "rsStream.h"
-
#include <utils/String8.h>
#include <utils/Vector.h>
+#include <cutils/atomic.h>
+#endif
+
+#include <stdint.h>
#include <stdlib.h>
#include <pthread.h>
#include <time.h>
-#include <cutils/atomic.h>
#include <math.h>
+#ifdef RS_SERVER
+
+#include <string>
+#include <vector>
+#include <algorithm>
+
+#define ALOGE(...)
+#define ALOGV(...)
+#define ALOGW(...)
+#define ALOGD(...)
+
+namespace android {
+
+ // server has no Vector or String8 classes; implement on top of STL
+ class String8: public std::string {
+ public:
+ String8(const char *ptr) : std::string(ptr) {
+
+ }
+ String8() : std::string() {
+
+ }
+
+ const char* string() const {
+ return this->c_str();
+ }
+
+ void setTo(const char* str, ssize_t len) {
+ this->assign(str, len);
+ }
+ void setTo(const char* str) {
+ this->assign(str);
+ }
+
+ };
+
+ template <class T> class Vector: public std::vector<T> {
+ public:
+ void push(T obj) {
+ this->push_back(obj);
+ }
+ void removeAt(uint32_t index) {
+ this->erase(this->begin() + index);
+ }
+ ssize_t add(const T& obj) {
+ this->push_back(obj);
+ return this->size() - 1;
+ }
+ void setCapacity(ssize_t capacity) {
+ this->resize(capacity);
+ }
+
+ T* editArray() {
+ return this->data();
+ }
+
+ const T* array() {
+ return this->data();
+ }
+
+ };
+
+ template<> class Vector<bool>: public std::vector<char> {
+ public:
+ void push(bool obj) {
+ this->push_back(obj);
+ }
+ void removeAt(uint32_t index) {
+ this->erase(this->begin() + index);
+ }
+ ssize_t add(const bool& obj) {
+ this->push_back(obj);
+ return this->size() - 1;
+ }
+ void setCapacity(ssize_t capacity) {
+ this->resize(capacity);
+ }
+
+ bool* editArray() {
+ return (bool*)this->data();
+ }
+
+ const bool* array() {
+ return (const bool*)this->data();
+ }
+ };
+
+}
+
+#endif // RS_SERVER
+
namespace android {
namespace renderscript {
diff --git a/server/RefBase.h b/server/RefBase.h
new file mode 100644
index 0000000..e1e5007
--- /dev/null
+++ b/server/RefBase.h
@@ -0,0 +1,528 @@
+/*
+ * Copyright (C) 2013 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_REF_BASE_H
+#define ANDROID_REF_BASE_H
+
+
+#include <stdint.h>
+#include <sys/types.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "StrongPointer.h"
+#include "TypeHelpers.h"
+
+// ---------------------------------------------------------------------------
+namespace android {
+
+class TextOutput;
+TextOutput& printWeakPointer(TextOutput& to, const void* val);
+
+// ---------------------------------------------------------------------------
+
+#define COMPARE_WEAK(_op_) \
+inline bool operator _op_ (const sp<T>& o) const { \
+ return m_ptr _op_ o.m_ptr; \
+} \
+inline bool operator _op_ (const T* o) const { \
+ return m_ptr _op_ o; \
+} \
+template<typename U> \
+inline bool operator _op_ (const sp<U>& o) const { \
+ return m_ptr _op_ o.m_ptr; \
+} \
+template<typename U> \
+inline bool operator _op_ (const U* o) const { \
+ return m_ptr _op_ o; \
+}
+
+// ---------------------------------------------------------------------------
+class ReferenceMover;
+class ReferenceConverterBase {
+public:
+ virtual size_t getReferenceTypeSize() const = 0;
+ virtual void* getReferenceBase(void const*) const = 0;
+ inline virtual ~ReferenceConverterBase() { }
+};
+
+// ---------------------------------------------------------------------------
+
+class RefBase
+{
+public:
+ void incStrong(const void* id) const;
+ void decStrong(const void* id) const;
+
+ void forceIncStrong(const void* id) const;
+
+ //! DEBUGGING ONLY: Get current strong ref count.
+ int32_t getStrongCount() const;
+
+ class weakref_type
+ {
+ public:
+ RefBase* refBase() const;
+
+ void incWeak(const void* id);
+ void decWeak(const void* id);
+
+ // acquires a strong reference if there is already one.
+ bool attemptIncStrong(const void* id);
+
+ // acquires a weak reference if there is already one.
+ // This is not always safe. see ProcessState.cpp and BpBinder.cpp
+ // for proper use.
+ bool attemptIncWeak(const void* id);
+
+ //! DEBUGGING ONLY: Get current weak ref count.
+ int32_t getWeakCount() const;
+
+ //! DEBUGGING ONLY: Print references held on object.
+ void printRefs() const;
+
+ //! DEBUGGING ONLY: Enable tracking for this object.
+ // enable -- enable/disable tracking
+ // retain -- when tracking is enable, if true, then we save a stack trace
+ // for each reference and dereference; when retain == false, we
+ // match up references and dereferences and keep only the
+ // outstanding ones.
+
+ void trackMe(bool enable, bool retain);
+ };
+
+ weakref_type* createWeak(const void* id) const;
+
+ weakref_type* getWeakRefs() const;
+
+ //! DEBUGGING ONLY: Print references held on object.
+ inline void printRefs() const { getWeakRefs()->printRefs(); }
+
+ //! DEBUGGING ONLY: Enable tracking of object.
+ inline void trackMe(bool enable, bool retain)
+ {
+ getWeakRefs()->trackMe(enable, retain);
+ }
+
+ typedef RefBase basetype;
+
+protected:
+ RefBase();
+ virtual ~RefBase();
+
+ //! Flags for extendObjectLifetime()
+ enum {
+ OBJECT_LIFETIME_STRONG = 0x0000,
+ OBJECT_LIFETIME_WEAK = 0x0001,
+ OBJECT_LIFETIME_MASK = 0x0001
+ };
+
+ void extendObjectLifetime(int32_t mode);
+
+ //! Flags for onIncStrongAttempted()
+ enum {
+ FIRST_INC_STRONG = 0x0001
+ };
+
+ virtual void onFirstRef();
+ virtual void onLastStrongRef(const void* id);
+ virtual bool onIncStrongAttempted(uint32_t flags, const void* id);
+ virtual void onLastWeakRef(const void* id);
+
+private:
+ friend class ReferenceMover;
+ static void moveReferences(void* d, void const* s, size_t n,
+ const ReferenceConverterBase& caster);
+
+private:
+ friend class weakref_type;
+ class weakref_impl;
+
+ RefBase(const RefBase& o);
+ RefBase& operator=(const RefBase& o);
+
+ weakref_impl* const mRefs;
+};
+
+// ---------------------------------------------------------------------------
+
+template <class T>
+class LightRefBase
+{
+public:
+ inline LightRefBase() : mCount(0) { }
+ inline void incStrong(__attribute__((unused)) const void* id) const {
+ __sync_fetch_and_add(&mCount, 1);
+ }
+ inline void decStrong(__attribute__((unused)) const void* id) const {
+ if (__sync_fetch_and_sub(&mCount, 1) == 1) {
+ delete static_cast<const T*>(this);
+ }
+ }
+ //! DEBUGGING ONLY: Get current strong ref count.
+ inline int32_t getStrongCount() const {
+ return mCount;
+ }
+
+ typedef LightRefBase<T> basetype;
+
+protected:
+ inline ~LightRefBase() { }
+
+private:
+ friend class ReferenceMover;
+ inline static void moveReferences(void* d, void const* s, size_t n,
+ const ReferenceConverterBase& caster) { }
+
+private:
+ mutable volatile int32_t mCount;
+};
+
+// ---------------------------------------------------------------------------
+
+template <typename T>
+class wp
+{
+public:
+ typedef typename RefBase::weakref_type weakref_type;
+
+ inline wp() : m_ptr(0) { }
+
+ wp(T* other);
+ wp(const wp<T>& other);
+ wp(const sp<T>& other);
+ template<typename U> wp(U* other);
+ template<typename U> wp(const sp<U>& other);
+ template<typename U> wp(const wp<U>& other);
+
+ ~wp();
+
+ // Assignment
+
+ wp& operator = (T* other);
+ wp& operator = (const wp<T>& other);
+ wp& operator = (const sp<T>& other);
+
+ template<typename U> wp& operator = (U* other);
+ template<typename U> wp& operator = (const wp<U>& other);
+ template<typename U> wp& operator = (const sp<U>& other);
+
+ void set_object_and_refs(T* other, weakref_type* refs);
+
+ // promotion to sp
+
+ sp<T> promote() const;
+
+ // Reset
+
+ void clear();
+
+ // Accessors
+
+ inline weakref_type* get_refs() const { return m_refs; }
+
+ inline T* unsafe_get() const { return m_ptr; }
+
+ // Operators
+
+ COMPARE_WEAK(==)
+ COMPARE_WEAK(!=)
+ COMPARE_WEAK(>)
+ COMPARE_WEAK(<)
+ COMPARE_WEAK(<=)
+ COMPARE_WEAK(>=)
+
+ inline bool operator == (const wp<T>& o) const {
+ return (m_ptr == o.m_ptr) && (m_refs == o.m_refs);
+ }
+ template<typename U>
+ inline bool operator == (const wp<U>& o) const {
+ return m_ptr == o.m_ptr;
+ }
+
+ inline bool operator > (const wp<T>& o) const {
+ return (m_ptr == o.m_ptr) ? (m_refs > o.m_refs) : (m_ptr > o.m_ptr);
+ }
+ template<typename U>
+ inline bool operator > (const wp<U>& o) const {
+ return (m_ptr == o.m_ptr) ? (m_refs > o.m_refs) : (m_ptr > o.m_ptr);
+ }
+
+ inline bool operator < (const wp<T>& o) const {
+ return (m_ptr == o.m_ptr) ? (m_refs < o.m_refs) : (m_ptr < o.m_ptr);
+ }
+ template<typename U>
+ inline bool operator < (const wp<U>& o) const {
+ return (m_ptr == o.m_ptr) ? (m_refs < o.m_refs) : (m_ptr < o.m_ptr);
+ }
+ inline bool operator != (const wp<T>& o) const { return m_refs != o.m_refs; }
+ template<typename U> inline bool operator != (const wp<U>& o) const { return !operator == (o); }
+ inline bool operator <= (const wp<T>& o) const { return !operator > (o); }
+ template<typename U> inline bool operator <= (const wp<U>& o) const { return !operator > (o); }
+ inline bool operator >= (const wp<T>& o) const { return !operator < (o); }
+ template<typename U> inline bool operator >= (const wp<U>& o) const { return !operator < (o); }
+
+private:
+ template<typename Y> friend class sp;
+ template<typename Y> friend class wp;
+
+ T* m_ptr;
+ weakref_type* m_refs;
+};
+
+template <typename T>
+TextOutput& operator<<(TextOutput& to, const wp<T>& val);
+
+#undef COMPARE_WEAK
+
+// ---------------------------------------------------------------------------
+// No user serviceable parts below here.
+
+template<typename T>
+wp<T>::wp(T* other)
+ : m_ptr(other)
+{
+ if (other) m_refs = other->createWeak(this);
+}
+
+template<typename T>
+wp<T>::wp(const wp<T>& other)
+ : m_ptr(other.m_ptr), m_refs(other.m_refs)
+{
+ if (m_ptr) m_refs->incWeak(this);
+}
+
+template<typename T>
+wp<T>::wp(const sp<T>& other)
+ : m_ptr(other.m_ptr)
+{
+ if (m_ptr) {
+ m_refs = m_ptr->createWeak(this);
+ }
+}
+
+template<typename T> template<typename U>
+wp<T>::wp(U* other)
+ : m_ptr(other)
+{
+ if (other) m_refs = other->createWeak(this);
+}
+
+template<typename T> template<typename U>
+wp<T>::wp(const wp<U>& other)
+ : m_ptr(other.m_ptr)
+{
+ if (m_ptr) {
+ m_refs = other.m_refs;
+ m_refs->incWeak(this);
+ }
+}
+
+template<typename T> template<typename U>
+wp<T>::wp(const sp<U>& other)
+ : m_ptr(other.m_ptr)
+{
+ if (m_ptr) {
+ m_refs = m_ptr->createWeak(this);
+ }
+}
+
+template<typename T>
+wp<T>::~wp()
+{
+ if (m_ptr) m_refs->decWeak(this);
+}
+
+template<typename T>
+wp<T>& wp<T>::operator = (T* other)
+{
+ weakref_type* newRefs =
+ other ? other->createWeak(this) : 0;
+ if (m_ptr) m_refs->decWeak(this);
+ m_ptr = other;
+ m_refs = newRefs;
+ return *this;
+}
+
+template<typename T>
+wp<T>& wp<T>::operator = (const wp<T>& other)
+{
+ weakref_type* otherRefs(other.m_refs);
+ T* otherPtr(other.m_ptr);
+ if (otherPtr) otherRefs->incWeak(this);
+ if (m_ptr) m_refs->decWeak(this);
+ m_ptr = otherPtr;
+ m_refs = otherRefs;
+ return *this;
+}
+
+template<typename T>
+wp<T>& wp<T>::operator = (const sp<T>& other)
+{
+ weakref_type* newRefs =
+ other != NULL ? other->createWeak(this) : 0;
+ T* otherPtr(other.m_ptr);
+ if (m_ptr) m_refs->decWeak(this);
+ m_ptr = otherPtr;
+ m_refs = newRefs;
+ return *this;
+}
+
+template<typename T> template<typename U>
+wp<T>& wp<T>::operator = (U* other)
+{
+ weakref_type* newRefs =
+ other ? other->createWeak(this) : 0;
+ if (m_ptr) m_refs->decWeak(this);
+ m_ptr = other;
+ m_refs = newRefs;
+ return *this;
+}
+
+template<typename T> template<typename U>
+wp<T>& wp<T>::operator = (const wp<U>& other)
+{
+ weakref_type* otherRefs(other.m_refs);
+ U* otherPtr(other.m_ptr);
+ if (otherPtr) otherRefs->incWeak(this);
+ if (m_ptr) m_refs->decWeak(this);
+ m_ptr = otherPtr;
+ m_refs = otherRefs;
+ return *this;
+}
+
+template<typename T> template<typename U>
+wp<T>& wp<T>::operator = (const sp<U>& other)
+{
+ weakref_type* newRefs =
+ other != NULL ? other->createWeak(this) : 0;
+ U* otherPtr(other.m_ptr);
+ if (m_ptr) m_refs->decWeak(this);
+ m_ptr = otherPtr;
+ m_refs = newRefs;
+ return *this;
+}
+
+template<typename T>
+void wp<T>::set_object_and_refs(T* other, weakref_type* refs)
+{
+ if (other) refs->incWeak(this);
+ if (m_ptr) m_refs->decWeak(this);
+ m_ptr = other;
+ m_refs = refs;
+}
+
+template<typename T>
+sp<T> wp<T>::promote() const
+{
+ sp<T> result;
+ if (m_ptr && m_refs->attemptIncStrong(&result)) {
+ result.set_pointer(m_ptr);
+ }
+ return result;
+}
+
+template<typename T>
+void wp<T>::clear()
+{
+ if (m_ptr) {
+ m_refs->decWeak(this);
+ m_ptr = 0;
+ }
+}
+
+template <typename T>
+inline TextOutput& operator<<(TextOutput& to, const wp<T>& val)
+{
+ return printWeakPointer(to, val.unsafe_get());
+}
+
+// ---------------------------------------------------------------------------
+
+// this class just serves as a namespace so TYPE::moveReferences can stay
+// private.
+
+class ReferenceMover {
+ // StrongReferenceCast and WeakReferenceCast do the impedance matching
+ // between the generic (void*) implementation in Refbase and the strongly typed
+ // template specializations below.
+
+ template <typename TYPE>
+ struct StrongReferenceCast : public ReferenceConverterBase {
+ virtual size_t getReferenceTypeSize() const { return sizeof( sp<TYPE> ); }
+ virtual void* getReferenceBase(void const* p) const {
+ sp<TYPE> const* sptr(reinterpret_cast<sp<TYPE> const*>(p));
+ return static_cast<typename TYPE::basetype *>(sptr->get());
+ }
+ };
+
+ template <typename TYPE>
+ struct WeakReferenceCast : public ReferenceConverterBase {
+ virtual size_t getReferenceTypeSize() const { return sizeof( wp<TYPE> ); }
+ virtual void* getReferenceBase(void const* p) const {
+ wp<TYPE> const* sptr(reinterpret_cast<wp<TYPE> const*>(p));
+ return static_cast<typename TYPE::basetype *>(sptr->unsafe_get());
+ }
+ };
+
+public:
+ template<typename TYPE> static inline
+ void move_references(sp<TYPE>* d, sp<TYPE> const* s, size_t n) {
+ memmove(d, s, n*sizeof(sp<TYPE>));
+ StrongReferenceCast<TYPE> caster;
+ TYPE::moveReferences(d, s, n, caster);
+ }
+ template<typename TYPE> static inline
+ void move_references(wp<TYPE>* d, wp<TYPE> const* s, size_t n) {
+ memmove(d, s, n*sizeof(wp<TYPE>));
+ WeakReferenceCast<TYPE> caster;
+ TYPE::moveReferences(d, s, n, caster);
+ }
+};
+
+// specialization for moving sp<> and wp<> types.
+// these are used by the [Sorted|Keyed]Vector<> implementations
+// sp<> and wp<> need to be handled specially, because they do not
+// have trivial copy operation in the general case (see RefBase.cpp
+// when DEBUG ops are enabled), but can be implemented very
+// efficiently in most cases.
+
+template<typename TYPE> inline
+void move_forward_type(sp<TYPE>* d, sp<TYPE> const* s, size_t n) {
+ ReferenceMover::move_references(d, s, n);
+}
+
+template<typename TYPE> inline
+void move_backward_type(sp<TYPE>* d, sp<TYPE> const* s, size_t n) {
+ ReferenceMover::move_references(d, s, n);
+}
+
+template<typename TYPE> inline
+void move_forward_type(wp<TYPE>* d, wp<TYPE> const* s, size_t n) {
+ ReferenceMover::move_references(d, s, n);
+}
+
+template<typename TYPE> inline
+void move_backward_type(wp<TYPE>* d, wp<TYPE> const* s, size_t n) {
+ ReferenceMover::move_references(d, s, n);
+}
+
+
+}; // namespace android
+
+// ---------------------------------------------------------------------------
+
+#endif // ANDROID_REF_BASE_H
diff --git a/server/StrongPointer.h b/server/StrongPointer.h
new file mode 100644
index 0000000..8983bd7
--- /dev/null
+++ b/server/StrongPointer.h
@@ -0,0 +1,220 @@
+/*
+ * Copyright (C) 2013 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_STRONG_POINTER_H
+#define ANDROID_STRONG_POINTER_H
+
+//#include <cutils/atomic.h>
+
+#include <stdint.h>
+#include <sys/types.h>
+#include <stdlib.h>
+
+// ---------------------------------------------------------------------------
+namespace android {
+
+class TextOutput;
+TextOutput& printStrongPointer(TextOutput& to, const void* val);
+
+template<typename T> class wp;
+
+// ---------------------------------------------------------------------------
+
+#define COMPARE(_op_) \
+inline bool operator _op_ (const sp<T>& o) const { \
+ return m_ptr _op_ o.m_ptr; \
+} \
+inline bool operator _op_ (const T* o) const { \
+ return m_ptr _op_ o; \
+} \
+template<typename U> \
+inline bool operator _op_ (const sp<U>& o) const { \
+ return m_ptr _op_ o.m_ptr; \
+} \
+template<typename U> \
+inline bool operator _op_ (const U* o) const { \
+ return m_ptr _op_ o; \
+} \
+inline bool operator _op_ (const wp<T>& o) const { \
+ return m_ptr _op_ o.m_ptr; \
+} \
+template<typename U> \
+inline bool operator _op_ (const wp<U>& o) const { \
+ return m_ptr _op_ o.m_ptr; \
+}
+
+// ---------------------------------------------------------------------------
+
+template <typename T>
+class sp
+{
+public:
+ inline sp() : m_ptr(0) { }
+
+ sp(T* other);
+ sp(const sp<T>& other);
+ template<typename U> sp(U* other);
+ template<typename U> sp(const sp<U>& other);
+
+ ~sp();
+
+ // Assignment
+
+ sp& operator = (T* other);
+ sp& operator = (const sp<T>& other);
+
+ template<typename U> sp& operator = (const sp<U>& other);
+ template<typename U> sp& operator = (U* other);
+
+ //! Special optimization for use by ProcessState (and nobody else).
+ void force_set(T* other);
+
+ // Reset
+
+ void clear();
+
+ // Accessors
+
+ inline T& operator* () const { return *m_ptr; }
+ inline T* operator-> () const { return m_ptr; }
+ inline T* get() const { return m_ptr; }
+
+ // Operators
+
+ COMPARE(==)
+ COMPARE(!=)
+ COMPARE(>)
+ COMPARE(<)
+ COMPARE(<=)
+ COMPARE(>=)
+
+private:
+ template<typename Y> friend class sp;
+ template<typename Y> friend class wp;
+ void set_pointer(T* ptr);
+ T* m_ptr;
+};
+
+#undef COMPARE
+
+template <typename T>
+TextOutput& operator<<(TextOutput& to, const sp<T>& val);
+
+// ---------------------------------------------------------------------------
+// No user serviceable parts below here.
+
+template<typename T>
+sp<T>::sp(T* other)
+: m_ptr(other)
+ {
+ if (other) other->incStrong(this);
+ }
+
+template<typename T>
+sp<T>::sp(const sp<T>& other)
+: m_ptr(other.m_ptr)
+ {
+ if (m_ptr) m_ptr->incStrong(this);
+ }
+
+template<typename T> template<typename U>
+sp<T>::sp(U* other) : m_ptr(other)
+{
+ if (other) ((T*)other)->incStrong(this);
+}
+
+template<typename T> template<typename U>
+sp<T>::sp(const sp<U>& other)
+: m_ptr(other.m_ptr)
+ {
+ if (m_ptr) m_ptr->incStrong(this);
+ }
+
+template<typename T>
+sp<T>::~sp()
+{
+ if (m_ptr) m_ptr->decStrong(this);
+}
+
+template<typename T>
+sp<T>& sp<T>::operator = (const sp<T>& other) {
+ T* otherPtr(other.m_ptr);
+ if (otherPtr) otherPtr->incStrong(this);
+ if (m_ptr) m_ptr->decStrong(this);
+ m_ptr = otherPtr;
+ return *this;
+}
+
+template<typename T>
+sp<T>& sp<T>::operator = (T* other)
+{
+ if (other) other->incStrong(this);
+ if (m_ptr) m_ptr->decStrong(this);
+ m_ptr = other;
+ return *this;
+}
+
+template<typename T> template<typename U>
+sp<T>& sp<T>::operator = (const sp<U>& other)
+{
+ T* otherPtr(other.m_ptr);
+ if (otherPtr) otherPtr->incStrong(this);
+ if (m_ptr) m_ptr->decStrong(this);
+ m_ptr = otherPtr;
+ return *this;
+}
+
+template<typename T> template<typename U>
+sp<T>& sp<T>::operator = (U* other)
+{
+ if (other) ((T*)other)->incStrong(this);
+ if (m_ptr) m_ptr->decStrong(this);
+ m_ptr = other;
+ return *this;
+}
+
+template<typename T>
+void sp<T>::force_set(T* other)
+{
+ other->forceIncStrong(this);
+ m_ptr = other;
+}
+
+template<typename T>
+void sp<T>::clear()
+{
+ if (m_ptr) {
+ m_ptr->decStrong(this);
+ m_ptr = 0;
+ }
+}
+
+template<typename T>
+void sp<T>::set_pointer(T* ptr) {
+ m_ptr = ptr;
+}
+
+template <typename T>
+inline TextOutput& operator<<(TextOutput& to, const sp<T>& val)
+{
+ return printStrongPointer(to, val.get());
+}
+
+}; // namespace android
+
+// ---------------------------------------------------------------------------
+
+#endif // ANDROID_STRONG_POINTER_H
diff --git a/server/TypeHelpers.h b/server/TypeHelpers.h
new file mode 100644
index 0000000..c74f945
--- /dev/null
+++ b/server/TypeHelpers.h
@@ -0,0 +1,302 @@
+/*
+ * Copyright (C) 2013 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_TYPE_HELPERS_H
+#define ANDROID_TYPE_HELPERS_H
+
+#include <new>
+#include <stdint.h>
+#include <string.h>
+#include <sys/types.h>
+
+// ---------------------------------------------------------------------------
+
+namespace android {
+
+/*
+ * Types traits
+ */
+
+template <typename T> struct trait_trivial_ctor { enum { value = false }; };
+template <typename T> struct trait_trivial_dtor { enum { value = false }; };
+template <typename T> struct trait_trivial_copy { enum { value = false }; };
+template <typename T> struct trait_trivial_move { enum { value = false }; };
+template <typename T> struct trait_pointer { enum { value = false }; };
+template <typename T> struct trait_pointer<T*> { enum { value = true }; };
+
+template <typename TYPE>
+struct traits {
+ enum {
+ // whether this type is a pointer
+ is_pointer = trait_pointer<TYPE>::value,
+ // whether this type's constructor is a no-op
+ has_trivial_ctor = is_pointer || trait_trivial_ctor<TYPE>::value,
+ // whether this type's destructor is a no-op
+ has_trivial_dtor = is_pointer || trait_trivial_dtor<TYPE>::value,
+ // whether this type type can be copy-constructed with memcpy
+ has_trivial_copy = is_pointer || trait_trivial_copy<TYPE>::value,
+ // whether this type can be moved with memmove
+ has_trivial_move = is_pointer || trait_trivial_move<TYPE>::value
+ };
+};
+
+template <typename T, typename U>
+struct aggregate_traits {
+ enum {
+ is_pointer = false,
+ has_trivial_ctor =
+ traits<T>::has_trivial_ctor && traits<U>::has_trivial_ctor,
+ has_trivial_dtor =
+ traits<T>::has_trivial_dtor && traits<U>::has_trivial_dtor,
+ has_trivial_copy =
+ traits<T>::has_trivial_copy && traits<U>::has_trivial_copy,
+ has_trivial_move =
+ traits<T>::has_trivial_move && traits<U>::has_trivial_move
+ };
+};
+
+#define ANDROID_TRIVIAL_CTOR_TRAIT( T ) \
+ template<> struct trait_trivial_ctor< T > { enum { value = true }; };
+
+#define ANDROID_TRIVIAL_DTOR_TRAIT( T ) \
+ template<> struct trait_trivial_dtor< T > { enum { value = true }; };
+
+#define ANDROID_TRIVIAL_COPY_TRAIT( T ) \
+ template<> struct trait_trivial_copy< T > { enum { value = true }; };
+
+#define ANDROID_TRIVIAL_MOVE_TRAIT( T ) \
+ template<> struct trait_trivial_move< T > { enum { value = true }; };
+
+#define ANDROID_BASIC_TYPES_TRAITS( T ) \
+ ANDROID_TRIVIAL_CTOR_TRAIT( T ) \
+ ANDROID_TRIVIAL_DTOR_TRAIT( T ) \
+ ANDROID_TRIVIAL_COPY_TRAIT( T ) \
+ ANDROID_TRIVIAL_MOVE_TRAIT( T )
+
+// ---------------------------------------------------------------------------
+
+/*
+ * basic types traits
+ */
+
+ANDROID_BASIC_TYPES_TRAITS( void )
+ANDROID_BASIC_TYPES_TRAITS( bool )
+ANDROID_BASIC_TYPES_TRAITS( char )
+ANDROID_BASIC_TYPES_TRAITS( unsigned char )
+ANDROID_BASIC_TYPES_TRAITS( short )
+ANDROID_BASIC_TYPES_TRAITS( unsigned short )
+ANDROID_BASIC_TYPES_TRAITS( int )
+ANDROID_BASIC_TYPES_TRAITS( unsigned int )
+ANDROID_BASIC_TYPES_TRAITS( long )
+ANDROID_BASIC_TYPES_TRAITS( unsigned long )
+ANDROID_BASIC_TYPES_TRAITS( long long )
+ANDROID_BASIC_TYPES_TRAITS( unsigned long long )
+ANDROID_BASIC_TYPES_TRAITS( float )
+ANDROID_BASIC_TYPES_TRAITS( double )
+
+// ---------------------------------------------------------------------------
+
+
+/*
+ * compare and order types
+ */
+
+template<typename TYPE> inline
+int strictly_order_type(const TYPE& lhs, const TYPE& rhs) {
+ return (lhs < rhs) ? 1 : 0;
+}
+
+template<typename TYPE> inline
+int compare_type(const TYPE& lhs, const TYPE& rhs) {
+ return strictly_order_type(rhs, lhs) - strictly_order_type(lhs, rhs);
+}
+
+/*
+ * create, destroy, copy and move types...
+ */
+
+template<typename TYPE> inline
+void construct_type(TYPE* p, size_t n) {
+ if (!traits<TYPE>::has_trivial_ctor) {
+ while (n--) {
+ new(p++) TYPE;
+ }
+ }
+}
+
+template<typename TYPE> inline
+void destroy_type(TYPE* p, size_t n) {
+ if (!traits<TYPE>::has_trivial_dtor) {
+ while (n--) {
+ p->~TYPE();
+ p++;
+ }
+ }
+}
+
+template<typename TYPE> inline
+void copy_type(TYPE* d, const TYPE* s, size_t n) {
+ if (!traits<TYPE>::has_trivial_copy) {
+ while (n--) {
+ new(d) TYPE(*s);
+ d++, s++;
+ }
+ } else {
+ memcpy(d,s,n*sizeof(TYPE));
+ }
+}
+
+template<typename TYPE> inline
+void splat_type(TYPE* where, const TYPE* what, size_t n) {
+ if (!traits<TYPE>::has_trivial_copy) {
+ while (n--) {
+ new(where) TYPE(*what);
+ where++;
+ }
+ } else {
+ while (n--) {
+ *where++ = *what;
+ }
+ }
+}
+
+template<typename TYPE> inline
+void move_forward_type(TYPE* d, const TYPE* s, size_t n = 1) {
+ if ((traits<TYPE>::has_trivial_dtor && traits<TYPE>::has_trivial_copy)
+ || traits<TYPE>::has_trivial_move)
+ {
+ memmove(d,s,n*sizeof(TYPE));
+ } else {
+ d += n;
+ s += n;
+ while (n--) {
+ --d, --s;
+ if (!traits<TYPE>::has_trivial_copy) {
+ new(d) TYPE(*s);
+ } else {
+ *d = *s;
+ }
+ if (!traits<TYPE>::has_trivial_dtor) {
+ s->~TYPE();
+ }
+ }
+ }
+}
+
+template<typename TYPE> inline
+void move_backward_type(TYPE* d, const TYPE* s, size_t n = 1) {
+ if ((traits<TYPE>::has_trivial_dtor && traits<TYPE>::has_trivial_copy)
+ || traits<TYPE>::has_trivial_move)
+ {
+ memmove(d,s,n*sizeof(TYPE));
+ } else {
+ while (n--) {
+ if (!traits<TYPE>::has_trivial_copy) {
+ new(d) TYPE(*s);
+ } else {
+ *d = *s;
+ }
+ if (!traits<TYPE>::has_trivial_dtor) {
+ s->~TYPE();
+ }
+ d++, s++;
+ }
+ }
+}
+
+// ---------------------------------------------------------------------------
+
+/*
+ * a key/value pair
+ */
+
+template <typename KEY, typename VALUE>
+struct key_value_pair_t {
+ typedef KEY key_t;
+ typedef VALUE value_t;
+
+ KEY key;
+ VALUE value;
+ key_value_pair_t() { }
+ key_value_pair_t(const key_value_pair_t& o) : key(o.key), value(o.value) { }
+ key_value_pair_t(const KEY& k, const VALUE& v) : key(k), value(v) { }
+ key_value_pair_t(const KEY& k) : key(k) { }
+ inline bool operator < (const key_value_pair_t& o) const {
+ return strictly_order_type(key, o.key);
+ }
+ inline const KEY& getKey() const {
+ return key;
+ }
+ inline const VALUE& getValue() const {
+ return value;
+ }
+};
+
+template <typename K, typename V>
+struct trait_trivial_ctor< key_value_pair_t<K, V> >
+{ enum { value = aggregate_traits<K,V>::has_trivial_ctor }; };
+template <typename K, typename V>
+struct trait_trivial_dtor< key_value_pair_t<K, V> >
+{ enum { value = aggregate_traits<K,V>::has_trivial_dtor }; };
+template <typename K, typename V>
+struct trait_trivial_copy< key_value_pair_t<K, V> >
+{ enum { value = aggregate_traits<K,V>::has_trivial_copy }; };
+template <typename K, typename V>
+struct trait_trivial_move< key_value_pair_t<K, V> >
+{ enum { value = aggregate_traits<K,V>::has_trivial_move }; };
+
+// ---------------------------------------------------------------------------
+
+/*
+ * Hash codes.
+ */
+typedef uint32_t hash_t;
+
+template <typename TKey>
+hash_t hash_type(const TKey& key);
+
+/* Built-in hash code specializations.
+ * Assumes pointers are 32bit. */
+#define ANDROID_INT32_HASH(T) \
+ template <> inline hash_t hash_type(const T& value) { return hash_t(value); }
+#define ANDROID_INT64_HASH(T) \
+ template <> inline hash_t hash_type(const T& value) { \
+ return hash_t((value >> 32) ^ value); }
+#define ANDROID_REINTERPRET_HASH(T, R) \
+ template <> inline hash_t hash_type(const T& value) { \
+ return hash_type(*reinterpret_cast<const R*>(&value)); }
+
+ANDROID_INT32_HASH(bool)
+ANDROID_INT32_HASH(int8_t)
+ANDROID_INT32_HASH(uint8_t)
+ANDROID_INT32_HASH(int16_t)
+ANDROID_INT32_HASH(uint16_t)
+ANDROID_INT32_HASH(int32_t)
+ANDROID_INT32_HASH(uint32_t)
+ANDROID_INT64_HASH(int64_t)
+ANDROID_INT64_HASH(uint64_t)
+ANDROID_REINTERPRET_HASH(float, uint32_t)
+ANDROID_REINTERPRET_HASH(double, uint64_t)
+
+template <typename T> inline hash_t hash_type(T* const & value) {
+ return hash_type(uintptr_t(value));
+}
+
+}; // namespace android
+
+// ---------------------------------------------------------------------------
+
+#endif // ANDROID_TYPE_HELPERS_H
