| /* |
| * Copyright 2017 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. |
| */ |
| |
| package android.graphics.cts; |
| |
| import static org.junit.Assert.assertEquals; |
| import static android.opengl.EGL14.*; |
| |
| import android.opengl.EGL14; |
| import android.opengl.EGLConfig; |
| import android.opengl.EGLContext; |
| import android.opengl.EGLDisplay; |
| import android.opengl.EGLSurface; |
| import android.opengl.GLES20; |
| import android.support.test.filters.SmallTest; |
| |
| import java.util.concurrent.CyclicBarrier; |
| |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.BlockJUnit4ClassRunner; |
| |
| |
| // This class contains tests for the Linux kernel sync file system, and the NDK interfaces for it |
| // (android/sync.h). Unfortunately, the interfaces exposed by the kernel make it difficult to test |
| // for a couple reasons: |
| // |
| // (a) There isn't a standard kernel interface for creating a fence/sync_file. Drivers can create |
| // them via driver-specific interfaces. Currently this means we have to use APIs like OpenGL ES |
| // or interact with the system compositor in order to generate fences. That makes tests larger |
| // and more complicated than they otherwise need to be. |
| // |
| // This is further complicated by the fact that most of the time GPU work executes in the order |
| // it was submitted to the kernel; there isn't much out-of-order execution in practice. So |
| // detecting some kinds of bugs is difficult using only the GPU as an event source. |
| // |
| // (b) A core principal of sync files is that they cannot be created until the work that will |
| // signal them has been submitted to the kernel, and will complete without further action from |
| // userland. This means that it is impossible to reliably do something before a sync file has |
| // signaled. |
| |
| @SmallTest |
| @RunWith(BlockJUnit4ClassRunner.class) |
| public class SyncTest { |
| |
| static { |
| System.loadLibrary("ctsgraphics_jni"); |
| } |
| |
| private static final String TAG = SyncTest.class.getSimpleName(); |
| private static final boolean DEBUG = false; |
| |
| private EGLDisplay mEglDisplay = EGL_NO_DISPLAY; |
| private EGLConfig mEglConfig = null; |
| |
| @Before |
| public void setup() throws Throwable { |
| mEglDisplay = EGL14.eglGetDisplay(EGL_DEFAULT_DISPLAY); |
| if (mEglDisplay == EGL_NO_DISPLAY) { |
| throw new RuntimeException("no EGL display"); |
| } |
| int[] major = new int[1]; |
| int[] minor = new int[1]; |
| if (!EGL14.eglInitialize(mEglDisplay, major, 0, minor, 0)) { |
| throw new RuntimeException("error in eglInitialize"); |
| } |
| |
| int[] numConfigs = new int[1]; |
| EGLConfig[] configs = new EGLConfig[1]; |
| if (!EGL14.eglChooseConfig(mEglDisplay, |
| new int[] { |
| EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, |
| EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, |
| EGL_BUFFER_SIZE, 32, |
| EGL_NONE}, |
| 0, configs, 0, 1, numConfigs, 0)) { |
| throw new RuntimeException("eglChooseConfig failed"); |
| } |
| mEglConfig = configs[0]; |
| } |
| |
| @After |
| public void teardown() throws Throwable { |
| EGL14.eglTerminate(mEglDisplay); |
| } |
| |
| @Test |
| public void testMergedSyncSignalOrder() { |
| // TODO |
| } |
| |
| private static final int STATUS_UNSIGNALED = 0; |
| private static final int STATUS_SIGNALED = 1; |
| private static final int STATUS_ERROR = -1; |
| private static class SyncFileInfo { |
| String name; // char name[32] |
| int status; // __s32 status |
| long flags; // __u32 flags |
| SyncFenceInfo[] fences; // __u32 num_fences; __u64 sync_fence_info |
| } |
| private static class SyncFenceInfo { |
| String name; // char obj_name[32] |
| String driver_name; // char driver_name[32] |
| int status; // __s32 status |
| long flags; // __u32 flags |
| long timestamp_ns; // __u64 timestamp_ns |
| } |
| |
| private static native boolean nSyncPoll(int[] fds, int[] status); |
| private static native int nSyncMerge(String name, int fd1, int fd2); |
| private static native SyncFileInfo nSyncFileInfo(int fd); |
| private static native void nSyncClose(int fd); |
| } |