Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1a2850fb authored by Michael Butler's avatar Michael Butler Committed by android-build-merger
Browse files

Merge "RenderScript VTS cleanup and fixes"

am: 7b361750

Change-Id: I03e7a64f197e7b47f7f7dbcd893cc3125fc06850
parents 1e7e3611 7b361750
Loading
Loading
Loading
Loading
+18 −35
Original line number Diff line number Diff line
@@ -43,9 +43,7 @@ TEST_F(RenderscriptHidlTest, Simple1DCopyTest) {
    context->allocation1DWrite(allocation, 0, 0, (Size)dataIn.size(), _data);
    context->allocation1DRead(allocation, 0, 0, (uint32_t)dataOut.size(), (Ptr)dataOut.data(),
                              (Size)dataOut.size()*sizeof(float));
    bool same = std::all_of(dataOut.begin(), dataOut.end(),
                            [](float x){ static int val = 0; return x == (float)val++; });
    EXPECT_EQ(true, same);
    EXPECT_EQ(dataIn, dataOut);
}

/*
@@ -76,9 +74,7 @@ TEST_F(RenderscriptHidlTest, Simple2DCopyTest) {
                               _data, 0);
    context->allocation2DRead(allocation, 0, 0, 0, AllocationCubemapFace::POSITIVE_X, 128, 128,
                              (Ptr)dataOut.data(), (Size)dataOut.size()*sizeof(float), 0);
    bool same = std::all_of(dataOut.begin(), dataOut.end(),
                            [](float x){ static int val = 0; return x == (float)val++; });
    EXPECT_EQ(true, same);
    EXPECT_EQ(dataIn, dataOut);
}

/*
@@ -108,9 +104,7 @@ TEST_F(RenderscriptHidlTest, Simple3DCopyTest) {
    context->allocation3DWrite(allocation, 0, 0, 0, 0, 32, 32, 32, _data, 0);
    context->allocation3DRead(allocation, 0, 0, 0, 0, 32, 32, 32, (Ptr)dataOut.data(),
                              (Size)dataOut.size()*sizeof(float), 0);
    bool same = std::all_of(dataOut.begin(), dataOut.end(),
                            [](float x){ static int val = 0; return x == (float)val++; });
    EXPECT_EQ(true, same);
    EXPECT_EQ(dataIn, dataOut);
}

/*
@@ -139,18 +133,14 @@ TEST_F(RenderscriptHidlTest, SimpleBitmapTest) {
                                                                AllocationMipmapControl::NONE,
                                                                _data,
                                                                (int)AllocationUsageType::SCRIPT);
    EXPECT_NE(allocation, Allocation(0));
    EXPECT_NE(Allocation(0), allocation);

    context->allocationCopyToBitmap(allocation, (Ptr)dataOut1.data(),
                                    (Size)dataOut1.size()*sizeof(float));
    bool same1 = std::all_of(dataOut1.begin(), dataOut1.end(),
                             [](float x){ static int val = 0; return x == (float)val++; });
    EXPECT_EQ(true, same1);
    EXPECT_EQ(dataIn, dataOut1);

    context->allocationRead(allocation, (Ptr)dataOut2.data(), (Size)dataOut2.size()*sizeof(float));
    bool same2 = std::all_of(dataOut2.begin(), dataOut2.end(),
                             [](float x){ static int val = 0; return x == (float)val++; });
    EXPECT_EQ(true, same2);
    EXPECT_EQ(dataIn, dataOut2);
}

/*
@@ -368,24 +358,20 @@ TEST_F(RenderscriptHidlTest, SimpleCubemapTest) {
/*
 * This test creates a complex element type (uint8_t, uint32_t) out of known
 * elements. It then verifies the element structure was created correctly.
 * Finally, the test creates a 128-wide, 1-dimension allocation of this type
 * and transfers memory to and from this structure.
 * Finally, the test creates a 1-wide, 1-dimension allocation of this type
 * and transfers memory to and from a single cell of this Allocation.
 *
 * Calls: elementCreate, elementComplexCreate, elementGetSubElements,
 * typeCreate, allocationCreateTyped, allocationElementWrite,
 * allocationElementRead
 *
 * This test currently has a bug, and should be fixed by 3/17.
 * TODO(butlermichael)
 */
/*
TEST_F(RenderscriptHidlTest, ComplexElementTest) {
    Element element1 = context->elementCreate(DataType::UNSIGNED_8, DataKind::USER, false, 1);
    Element element2 = context->elementCreate(DataType::UNSIGNED_32, DataKind::USER, false, 1);

    hidl_vec<Element> eins = {element1, element2};
    hidl_vec<hidl_string> names = {hidl_string("first"), hidl_string("second")};
    hidl_vec<Size> arraySizesPtr = {sizeof(uint8_t), sizeof(uint32_t)};
    hidl_vec<Size> arraySizesPtr = {1, 1};
    Element element3 = context->elementComplexCreate(eins, names, arraySizesPtr);
    EXPECT_NE(Element(0), element3);

@@ -400,28 +386,25 @@ TEST_F(RenderscriptHidlTest, ComplexElementTest) {
                                                        namesOut.push_back(_names[1]);
                                                        arraySizesOut = _arraySizes;
                                                    });
    EXPECT_NE(Element(0), ids[0]);
    EXPECT_NE(Element(0), ids[1]);
    EXPECT_EQ(element1, ids[0]);
    EXPECT_EQ(element2, ids[1]);
    EXPECT_EQ("first", namesOut[0]);
    EXPECT_EQ("second", namesOut[1]);
    EXPECT_EQ(sizeof(uint8_t), arraySizesOut[0]);
    EXPECT_EQ(sizeof(uint32_t), arraySizesOut[1]);
    EXPECT_EQ(Size(1), arraySizesOut[0]);
    EXPECT_EQ(Size(1), arraySizesOut[1]);

    // 128 x (uint8_t, uint32_t)
    Type type = context->typeCreate(element3, 128, 0, 0, false, false, YuvFormat::YUV_NONE);
    // 128 x (uint8_t, uint32_t)
    // 1 x (uint8_t, uint32_t)
    Type type = context->typeCreate(element3, 1, 0, 0, false, false, YuvFormat::YUV_NONE);
    // 1 x (uint8_t, uint32_t)
    Allocation allocation = context->allocationCreateTyped(type, AllocationMipmapControl::NONE,
                                                           (int)AllocationUsageType::SCRIPT,
                                                           (Ptr)nullptr);
    std::vector<uint32_t> dataIn(128), dataOut(128);
    std::vector<uint32_t> dataIn(1), dataOut(1);
    std::generate(dataIn.begin(), dataIn.end(), [](){ static uint32_t val = 0; return val++; });
    hidl_vec<uint8_t> _data;
    _data.setToExternal((uint8_t*)dataIn.data(), dataIn.size()*sizeof(uint32_t));
    context->allocationElementWrite(allocation, 0, 0, 0, 0, _data, 1);
    context->allocationElementRead(allocation, 0, 0, 0, 0, (Ptr)dataOut.data(),
                                   (Size)dataOut.size()*sizeof(uint32_t), 1);
    bool same = std::all_of(dataOut.begin(), dataOut.end(),
                            [](uint32_t x){ static uint32_t val = 0; return x == val++; });
    EXPECT_EQ(true, same);
    EXPECT_EQ(dataIn, dataOut);
}
*/
+21 −1
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ using ::android::hardware::renderscript::V1_0::AllocationAdapter;
using ::android::hardware::renderscript::V1_0::AllocationCubemapFace;
using ::android::hardware::renderscript::V1_0::AllocationMipmapControl;
using ::android::hardware::renderscript::V1_0::AllocationUsageType;
using ::android::hardware::renderscript::V1_0::Closure;
using ::android::hardware::renderscript::V1_0::IContext;
using ::android::hardware::renderscript::V1_0::IDevice;
using ::android::hardware::renderscript::V1_0::ContextType;
@@ -62,7 +63,26 @@ using ::android::hardware::hidl_vec;
using ::android::hardware::hidl_string;
using ::android::sp;

// bitcode variables
// bitcode slots
extern const int mExportVarIdx_var_int;
extern const int mExportVarIdx_var_long;
extern const int mExportVarIdx_var_float;
extern const int mExportVarIdx_var_double;
extern const int mExportVarIdx_var_allocation;
extern const int mExportVarIdx_var_uint32_t;
extern const int mExportVarIdx_var_point2;
extern const int mExportVarIdx_var_int_ptr;
// bitcode invoke slots
//extern const int mExportForEachIdx_root;
extern const int mExportForEachIdx_increment;
// bitcode reduce slots
extern const int mExportReduceIdx_summation;
// bitcode invoke slots
extern const int mExportFuncIdx_function;
extern const int mExportFuncIdx_functionV;
extern const int mExportFuncIdx_setBuffer;
extern const int mExportFuncIdx_setAllocation;
// bitcode
typedef signed char int8_t;
extern const int8_t bitCode[];
extern const int bitCodeLength;
+51 −42
Original line number Diff line number Diff line
@@ -15,6 +15,7 @@
 */

#include "VtsHalRenderscriptV1_0TargetTest.h"
#include <system/window.h>

/*
 * ContextCreateAndDestroy:
@@ -81,7 +82,7 @@ TEST_F(RenderscriptHidlTest, MetadataTest) {
                                          elementMetadata = _metadata; });
    EXPECT_EQ(DataType::FLOAT_32, (DataType)elementMetadata[0]);
    EXPECT_EQ(DataKind::USER, (DataKind)elementMetadata[1]);
    EXPECT_EQ(false, ((uint32_t)elementMetadata[2] == 1) ? true : false);
    EXPECT_EQ(false, elementMetadata[2]);
    EXPECT_EQ(1u, (uint32_t)elementMetadata[3]);
    EXPECT_EQ(0u, (uint32_t)elementMetadata[4]);

@@ -134,21 +135,17 @@ TEST_F(RenderscriptHidlTest, ResizeTest) {
 * Calls: elementCreate, typeCreate, allocationCreateTyped, allocation2DWrite,
 * allocationGetNativeWindow, allocationSetNativeWindow, allocationIoSend,
 * allocationIoReceive, allocation2DRead
 *
 * This test currently has a bug, and should be fixed by 3/17.
 * TODO(butlermichael)
 */
/*
TEST_F(RenderscriptHidlTest, NativeWindowIoTest) {
    // uint8x4
    Element element = context->elementCreate(DataType::UNSIGNED_8, DataKind::USER, false, 4);
    // 512 x 512 x uint8x4
    Type type = context->typeCreate(element, 512, 512, 0, false, false, YuvFormat::YUV_NONE);
    std::vector<uint32_t> dataIn(512*512), dataOut(512*512);
    std::generate(dataIn.begin(), dataIn.end(), [](){ static int val = 0; return (uint32_t)val++; });
    std::generate(dataIn.begin(), dataIn.end(), [](){ static uint32_t val = 0; return val++; });
    hidl_vec<uint8_t> _data;
    _data.setToExternal((uint8_t*)dataIn.data(), dataIn.size()*sizeof(uint32_t));
    // 512 x 512 x float1
    // 512 x 512 x uint8x4
    Allocation allocationRecv = context->allocationCreateTyped(type, AllocationMipmapControl::NONE,
                                                               (int)(AllocationUsageType::SCRIPT
                                                               | AllocationUsageType::IO_INPUT),
@@ -157,21 +154,20 @@ TEST_F(RenderscriptHidlTest, NativeWindowIoTest) {
                                                               (int)(AllocationUsageType::SCRIPT
                                                               | AllocationUsageType::IO_OUTPUT),
                                                               (Ptr)nullptr);
    context->allocation2DWrite(allocationSend, 0, 0, 0, AllocationCubemapFace::POSITIVE_X, 512, 512,
                               _data, 0);
    NativeWindow nativeWindow = context->allocationGetNativeWindow(allocationRecv);
    EXPECT_NE(NativeWindow(0), nativeWindow);

    ((ANativeWindow *)nativeWindow)->incStrong(nullptr);

    context->allocationSetNativeWindow(allocationSend, nativeWindow);
    context->allocation2DWrite(allocationSend, 0, 0, 0, AllocationCubemapFace::POSITIVE_X, 512, 512,
                               _data, 0);
    context->allocationIoSend(allocationSend);
    context->allocationIoReceive(allocationRecv);
    context->allocation2DRead(allocationRecv, 0, 0, 0, AllocationCubemapFace::POSITIVE_X, 512, 512,
                              (Ptr)dataOut.data(), (Size)dataOut.size()*sizeof(uint32_t), 0);
    bool same = std::all_of(dataOut.begin(), dataOut.end(),
                             [](uint32_t x){ static int val = 0; return x == (uint32_t)val++; });
    EXPECT_EQ(true, same);
    EXPECT_EQ(dataIn, dataOut);
}
*/

/*
 * Three allocations are created, two with IO_INPUT and one with IO_OUTPUT. The
@@ -180,21 +176,17 @@ TEST_F(RenderscriptHidlTest, NativeWindowIoTest) {
 * Calls: elementCreate, typeCreate, allocationCreateTyped,
 * allocationCreateFromBitmap, allocationSetupBufferQueue,
 * allocationShareBufferQueue
 *
 * This test currently has a bug, and should be fixed by 3/17.
 * TODO(butlermichael)
 */
/*
TEST_F(RenderscriptHidlTest, BufferQueueTest) {
    // float1
    Element element = context->elementCreate(DataType::FLOAT_32, DataKind::USER, false, 1);
    // 512 x 512 x float1
    // uint8x4
    Element element = context->elementCreate(DataType::UNSIGNED_8, DataKind::USER, false, 4);
    // 512 x 512 x uint8x4
    Type type = context->typeCreate(element, 512, 512, 0, false, false, YuvFormat::YUV_NONE);
    std::vector<float> dataIn(512*512), dataOut1(512*512), dataOut2(512*512);
    std::generate(dataIn.begin(), dataIn.end(), [](){ static int val = 0; return (float)val++; });
    std::vector<uint32_t> dataIn(512*512), dataOut1(512*512), dataOut2(512*512);
    std::generate(dataIn.begin(), dataIn.end(), [](){ static uint32_t val = 0; return val++; });
    hidl_vec<uint8_t> _data;
    _data.setToExternal((uint8_t*)dataIn.data(), dataIn.size()*sizeof(float));
    // 512 x 512 x float1
    _data.setToExternal((uint8_t*)dataIn.data(), dataIn.size()*sizeof(uint32_t));
    // 512 x 512 x uint8x4
    Allocation allocationRecv1 = context->allocationCreateTyped(type, AllocationMipmapControl::NONE,
                                                                (int)(AllocationUsageType::SCRIPT
                                                                | AllocationUsageType::IO_INPUT),
@@ -203,16 +195,37 @@ TEST_F(RenderscriptHidlTest, BufferQueueTest) {
                                                                (int)(AllocationUsageType::SCRIPT
                                                                | AllocationUsageType::IO_INPUT),
                                                                (Ptr)nullptr);
    Allocation allocationSend = context->allocationCreateFromBitmap(type,
                                                                    AllocationMipmapControl::NONE,
                                                                    _data,
    Allocation allocationSend  = context->allocationCreateTyped(type, AllocationMipmapControl::NONE,
                                                                (int)(AllocationUsageType::SCRIPT
                                                                 | AllocationUsageType::IO_OUTPUT));
                                                                | AllocationUsageType::IO_INPUT),
                                                                (Ptr)nullptr);
    context->allocationSetupBufferQueue(allocationRecv1, 2);
    context->allocationShareBufferQueue(allocationRecv1, allocationRecv2);
    // TODO: test the buffer queue
    context->allocationShareBufferQueue(allocationRecv2, allocationRecv1);

    NativeWindow nativeWindow1 = context->allocationGetNativeWindow(allocationRecv1);
    EXPECT_NE(NativeWindow(0), nativeWindow1);
    NativeWindow nativeWindow2 = context->allocationGetNativeWindow(allocationRecv2);
    EXPECT_EQ(nativeWindow2, nativeWindow1);

    ((ANativeWindow *)nativeWindow1)->incStrong(nullptr);

    context->allocationSetNativeWindow(allocationSend, nativeWindow1);
    context->allocation2DWrite(allocationSend, 0, 0, 0, AllocationCubemapFace::POSITIVE_X, 512, 512,
                               _data, 0);
    context->allocationIoSend(allocationSend);
    context->allocationIoReceive(allocationRecv1);
    context->allocation2DRead(allocationRecv1, 0, 0, 0, AllocationCubemapFace::POSITIVE_X, 512, 512,
                              (Ptr)dataOut1.data(), (Size)dataOut1.size()*sizeof(uint32_t), 0);
    EXPECT_EQ(dataIn, dataOut1);

    context->allocation2DWrite(allocationSend, 0, 0, 0, AllocationCubemapFace::POSITIVE_X, 512, 512,
                               _data, 0);
    context->allocationIoSend(allocationSend);
    context->allocationIoReceive(allocationRecv2);
    context->allocation2DRead(allocationRecv2, 0, 0, 0, AllocationCubemapFace::POSITIVE_X, 512, 512,
                              (Ptr)dataOut2.data(), (Size)dataOut2.size()*sizeof(uint32_t), 0);
    EXPECT_EQ(dataIn, dataOut2);
}
*/

/*
 * This test sets up the message queue, sends a message, peeks at the message,
@@ -220,33 +233,29 @@ TEST_F(RenderscriptHidlTest, BufferQueueTest) {
 *
 * Calls: contextInitToClient, contextSendMessage, contextPeekMessage,
 * contextGetMessage, contextDeinitToClient, contextLog
 *
 * This test currently has a bug, and should be fixed by 3/17.
 * TODO(butlermichael)
 */
/*
TEST_F(RenderscriptHidlTest, ContextMessageTest) {
    context->contextInitToClient();

    std::string messageOut = "correct";
    const char * message = "correct";
    std::vector<char> messageSend(message, message + sizeof(message));
    hidl_vec<uint8_t> _data;
    _data.setToExternal((uint8_t*)const_cast<char*>(messageOut.c_str()), messageOut.length());
    _data.setToExternal((uint8_t*)messageSend.data(), messageSend.size());
    context->contextSendMessage(0, _data);
    MessageToClientType messageType;
    size_t size;
    uint32_t subID;
    context->contextPeekMessage([&](MessageToClientType _type, Size _size, uint32_t _subID){
                                messageType = _type; size = (uint32_t)_size; subID = _subID; });
    std::vector<char> messageIn(size, '\0');
    context->contextGetMessage(messageIn.data(), messageIn.size(),
    std::vector<char> messageRecv(size, '\0');
    context->contextGetMessage(messageRecv.data(), messageRecv.size(),
                               [&](MessageToClientType _type, Size _size){
                               messageType = _type; size = (uint32_t)_size; });
    EXPECT_EQ(messageOut, messageIn.data());
    EXPECT_EQ(messageSend, messageRecv);

    context->contextDeinitToClient();
    context->contextLog();
}
*/

/*
 * Call through a bunch of APIs and make sure they don’t crash. Assign the name
+216 −117

File changed.

Preview size limit exceeded, changes collapsed.

+473 −354

File changed.

Preview size limit exceeded, changes collapsed.