vp9_thread_test.cc 9.97 KB
Newer Older
1 2 3 4 5 6 7 8 9 10
/*
 *  Copyright (c) 2013 The WebM project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

11
#include <string>
12 13

#include "third_party/googletest/src/include/gtest/gtest.h"
14
#include "./vpx_config.h"
15 16 17
#include "test/codec_factory.h"
#include "test/decode_test_driver.h"
#include "test/md5_helper.h"
18
#if CONFIG_WEBM_IO
19
#include "test/webm_video_source.h"
20
#endif
21
#include "vpx_util/vpx_thread.h"
22 23 24

namespace {

25 26
using std::string;

27
class VPxWorkerThreadTest : public ::testing::TestWithParam<bool> {
28
 protected:
29
  virtual ~VPxWorkerThreadTest() {}
30
  virtual void SetUp() {
31
    vpx_get_worker_interface()->init(&worker_);
32 33 34
  }

  virtual void TearDown() {
35
    vpx_get_worker_interface()->end(&worker_);
36 37
  }

38
  void Run(VPxWorker* worker) {
James Zern's avatar
James Zern committed
39 40
    const bool synchronous = GetParam();
    if (synchronous) {
41
      vpx_get_worker_interface()->execute(worker);
James Zern's avatar
James Zern committed
42
    } else {
43
      vpx_get_worker_interface()->launch(worker);
James Zern's avatar
James Zern committed
44 45 46
    }
  }

47
  VPxWorker worker_;
48 49 50 51 52 53 54 55
};

int ThreadHook(void* data, void* return_value) {
  int* const hook_data = reinterpret_cast<int*>(data);
  *hook_data = 5;
  return *reinterpret_cast<int*>(return_value);
}

56
TEST_P(VPxWorkerThreadTest, HookSuccess) {
James Zern's avatar
James Zern committed
57
  // should be a no-op.
58
  EXPECT_NE(vpx_get_worker_interface()->sync(&worker_), 0);
59 60

  for (int i = 0; i < 2; ++i) {
61
    EXPECT_NE(vpx_get_worker_interface()->reset(&worker_), 0);
62 63 64 65 66 67 68

    int hook_data = 0;
    int return_value = 1;  // return successfully from the hook
    worker_.hook = ThreadHook;
    worker_.data1 = &hook_data;
    worker_.data2 = &return_value;

James Zern's avatar
James Zern committed
69
    Run(&worker_);
70
    EXPECT_NE(vpx_get_worker_interface()->sync(&worker_), 0);
71 72 73
    EXPECT_FALSE(worker_.had_error);
    EXPECT_EQ(5, hook_data);

James Zern's avatar
James Zern committed
74
    // should be a no-op.
75
    EXPECT_NE(vpx_get_worker_interface()->sync(&worker_), 0);
76 77 78
  }
}

79 80
TEST_P(VPxWorkerThreadTest, HookFailure) {
  EXPECT_NE(vpx_get_worker_interface()->reset(&worker_), 0);
81 82 83 84 85 86 87

  int hook_data = 0;
  int return_value = 0;  // return failure from the hook
  worker_.hook = ThreadHook;
  worker_.data1 = &hook_data;
  worker_.data2 = &return_value;

James Zern's avatar
James Zern committed
88
  Run(&worker_);
89
  EXPECT_FALSE(vpx_get_worker_interface()->sync(&worker_));
90
  EXPECT_EQ(1, worker_.had_error);
91 92 93

  // Ensure _reset() clears the error and _launch() can be called again.
  return_value = 1;
94
  EXPECT_NE(vpx_get_worker_interface()->reset(&worker_), 0);
95
  EXPECT_FALSE(worker_.had_error);
96 97
  vpx_get_worker_interface()->launch(&worker_);
  EXPECT_NE(vpx_get_worker_interface()->sync(&worker_), 0);
98 99 100
  EXPECT_FALSE(worker_.had_error);
}

101
TEST_P(VPxWorkerThreadTest, EndWithoutSync) {
James Zern's avatar
James Zern committed
102 103 104 105
  // Create a large number of threads to increase the chances of detecting a
  // race. Doing more work in the hook is no guarantee as any race would occur
  // post hook execution in the main thread loop driver.
  static const int kNumWorkers = 64;
106
  VPxWorker workers[kNumWorkers];
James Zern's avatar
James Zern committed
107 108 109 110
  int hook_data[kNumWorkers];
  int return_value[kNumWorkers];

  for (int n = 0; n < kNumWorkers; ++n) {
111
    vpx_get_worker_interface()->init(&workers[n]);
James Zern's avatar
James Zern committed
112 113 114 115 116 117 118 119
    return_value[n] = 1;  // return successfully from the hook
    workers[n].hook = ThreadHook;
    workers[n].data1 = &hook_data[n];
    workers[n].data2 = &return_value[n];
  }

  for (int i = 0; i < 2; ++i) {
    for (int n = 0; n < kNumWorkers; ++n) {
120
      EXPECT_NE(vpx_get_worker_interface()->reset(&workers[n]), 0);
James Zern's avatar
James Zern committed
121 122 123 124 125 126 127 128
      hook_data[n] = 0;
    }

    for (int n = 0; n < kNumWorkers; ++n) {
      Run(&workers[n]);
    }

    for (int n = kNumWorkers - 1; n >= 0; --n) {
129
      vpx_get_worker_interface()->end(&workers[n]);
James Zern's avatar
James Zern committed
130 131 132 133
    }
  }
}

134 135 136
TEST(VPxWorkerThreadTest, TestInterfaceAPI) {
  EXPECT_EQ(0, vpx_set_worker_interface(NULL));
  EXPECT_TRUE(vpx_get_worker_interface() != NULL);
James Zern's avatar
James Zern committed
137
  for (int i = 0; i < 6; ++i) {
138
    VPxWorkerInterface winterface = *vpx_get_worker_interface();
James Zern's avatar
James Zern committed
139 140 141 142 143 144 145 146 147
    switch (i) {
      default:
      case 0: winterface.init = NULL; break;
      case 1: winterface.reset = NULL; break;
      case 2: winterface.sync = NULL; break;
      case 3: winterface.launch = NULL; break;
      case 4: winterface.execute = NULL; break;
      case 5: winterface.end = NULL; break;
    }
148
    EXPECT_EQ(0, vpx_set_worker_interface(&winterface));
James Zern's avatar
James Zern committed
149 150 151
  }
}

152 153 154
// -----------------------------------------------------------------------------
// Multi-threaded decode tests

155
#if CONFIG_WEBM_IO
156 157 158 159 160
struct FileList {
  const char *name;
  const char *expected_md5;
};

161 162 163
// Decodes |filename| with |num_threads|. Returns the md5 of the decoded frames.
string DecodeFile(const string& filename, int num_threads) {
  libvpx_test::WebMVideoSource video(filename);
164 165
  video.Init();

166
  vpx_codec_dec_cfg_t cfg = vpx_codec_dec_cfg_t();
167
  cfg.threads = num_threads;
168 169 170 171 172 173
  libvpx_test::VP9Decoder decoder(cfg, 0);

  libvpx_test::MD5 md5;
  for (video.Begin(); video.cxdata(); video.Next()) {
    const vpx_codec_err_t res =
        decoder.DecodeFrame(video.cxdata(), video.frame_size());
174 175 176 177
    if (res != VPX_CODEC_OK) {
      EXPECT_EQ(VPX_CODEC_OK, res) << decoder.DecodeError();
      break;
    }
178 179 180 181 182 183 184 185 186

    libvpx_test::DxDataIterator dec_iter = decoder.GetDxData();
    const vpx_image_t *img = NULL;

    // Get decompressed data
    while ((img = dec_iter.Next())) {
      md5.Add(img);
    }
  }
187 188 189
  return string(md5.Get());
}

190 191 192 193
void DecodeFiles(const FileList files[]) {
  for (const FileList *iter = files; iter->name != NULL; ++iter) {
    SCOPED_TRACE(iter->name);
    for (int t = 2; t <= 8; ++t) {
194
      EXPECT_EQ(iter->expected_md5, DecodeFile(iter->name, t))
195 196 197 198 199
          << "threads = " << t;
    }
  }
}

James Zern's avatar
James Zern committed
200 201 202 203 204
// Trivial serialized thread worker interface implementation.
// Note any worker that requires synchronization between other workers will
// hang.
namespace impl {

205 206 207
void Init(VPxWorker *const worker) { memset(worker, 0, sizeof(*worker)); }
int Reset(VPxWorker *const /*worker*/) { return 1; }
int Sync(VPxWorker *const worker) { return !worker->had_error; }
James Zern's avatar
James Zern committed
208

209
void Execute(VPxWorker *const worker) {
210
  worker->had_error |= !worker->hook(worker->data1, worker->data2);
James Zern's avatar
James Zern committed
211 212
}

213 214
void Launch(VPxWorker *const worker) { Execute(worker); }
void End(VPxWorker *const /*worker*/) {}
James Zern's avatar
James Zern committed
215 216 217

}  // namespace impl

218 219
TEST(VPxWorkerThreadTest, TestSerialInterface) {
  static const VPxWorkerInterface serial_interface = {
James Zern's avatar
James Zern committed
220 221 222 223 224 225 226 227
    impl::Init, impl::Reset, impl::Sync, impl::Launch, impl::Execute, impl::End
  };
  // TODO(jzern): Avoid using a file that will use the row-based thread
  // loopfilter, with the simple serialized implementation it will hang. This is
  // due to its expectation that rows will be run in parallel as they wait on
  // progress in the row above before proceeding.
  static const char expected_md5[] = "b35a1b707b28e82be025d960aba039bc";
  static const char filename[] = "vp90-2-03-size-226x226.webm";
228
  VPxWorkerInterface default_interface = *vpx_get_worker_interface();
James Zern's avatar
James Zern committed
229

230
  EXPECT_NE(vpx_set_worker_interface(&serial_interface), 0);
James Zern's avatar
James Zern committed
231 232 233
  EXPECT_EQ(expected_md5, DecodeFile(filename, 2));

  // Reset the interface.
234
  EXPECT_NE(vpx_set_worker_interface(&default_interface), 0);
James Zern's avatar
James Zern committed
235 236 237
  EXPECT_EQ(expected_md5, DecodeFile(filename, 2));
}

238
TEST(VP9DecodeMultiThreadedTest, Decode) {
239
  // no tiles or frame parallel; this exercises loop filter threading.
240 241
  EXPECT_EQ("b35a1b707b28e82be025d960aba039bc",
            DecodeFile("vp90-2-03-size-226x226.webm", 2));
242 243
}

244
TEST(VP9DecodeMultiThreadedTest, Decode2) {
245
  static const FileList files[] = {
246 247 248 249
    { "vp90-2-08-tile_1x2_frame_parallel.webm",
      "68ede6abd66bae0a2edf2eb9232241b6" },
    { "vp90-2-08-tile_1x4_frame_parallel.webm",
      "368ebc6ebf3a5e478d85b2c3149b2848" },
James Zern's avatar
James Zern committed
250 251
    { "vp90-2-08-tile_1x8_frame_parallel.webm",
      "17e439da2388aff3a0f69cb22579c6c1" },
252
    { NULL, NULL }
253 254
  };

255
  DecodeFiles(files);
256 257
}

258
// Test tile quantity changes within one file.
259
TEST(VP9DecodeMultiThreadedTest, Decode3) {
260
  static const FileList files[] = {
261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304
    { "vp90-2-14-resize-fp-tiles-1-16.webm",
      "0cd5e632c326297e975f38949c31ea94" },
    { "vp90-2-14-resize-fp-tiles-1-2-4-8-16.webm",
      "5c78a96a42e7f4a4f6b2edcdb791e44c" },
    { "vp90-2-14-resize-fp-tiles-1-2.webm",
      "e030450ae85c3277be2a418769df98e2" },
    { "vp90-2-14-resize-fp-tiles-1-4.webm",
      "312eed4e2b64eb7a4e7f18916606a430" },
    { "vp90-2-14-resize-fp-tiles-16-1.webm",
      "1755c16d8af16a9cb3fe7338d90abe52" },
    { "vp90-2-14-resize-fp-tiles-16-2.webm",
      "500300592d3fcb6f12fab25e48aaf4df" },
    { "vp90-2-14-resize-fp-tiles-16-4.webm",
      "47c48379fa6331215d91c67648e1af6e" },
    { "vp90-2-14-resize-fp-tiles-16-8-4-2-1.webm",
      "eecf17290739bc708506fa4827665989" },
    { "vp90-2-14-resize-fp-tiles-16-8.webm",
      "29b6bb54e4c26b5ca85d5de5fed94e76" },
    { "vp90-2-14-resize-fp-tiles-1-8.webm",
      "1b6f175e08cd82cf84bb800ac6d1caa3" },
    { "vp90-2-14-resize-fp-tiles-2-16.webm",
      "ca3b03e4197995d8d5444ede7a6c0804" },
    { "vp90-2-14-resize-fp-tiles-2-1.webm",
      "99aec065369d70bbb78ccdff65afed3f" },
    { "vp90-2-14-resize-fp-tiles-2-4.webm",
      "22d0ebdb49b87d2920a85aea32e1afd5" },
    { "vp90-2-14-resize-fp-tiles-2-8.webm",
      "c2115cf051c62e0f7db1d4a783831541" },
    { "vp90-2-14-resize-fp-tiles-4-16.webm",
      "c690d7e1719b31367564cac0af0939cb" },
    { "vp90-2-14-resize-fp-tiles-4-1.webm",
      "a926020b2cc3e15ad4cc271853a0ff26" },
    { "vp90-2-14-resize-fp-tiles-4-2.webm",
      "42699063d9e581f1993d0cf890c2be78" },
    { "vp90-2-14-resize-fp-tiles-4-8.webm",
      "7f76d96036382f45121e3d5aa6f8ec52" },
    { "vp90-2-14-resize-fp-tiles-8-16.webm",
      "76a43fcdd7e658542913ea43216ec55d" },
    { "vp90-2-14-resize-fp-tiles-8-1.webm",
      "8e3fbe89486ca60a59299dea9da91378" },
    { "vp90-2-14-resize-fp-tiles-8-2.webm",
      "ae96f21f21b6370cc0125621b441fc52" },
    { "vp90-2-14-resize-fp-tiles-8-4.webm",
      "3eb4f24f10640d42218f7fd7b9fd30d4" },
305
    { NULL, NULL }
306 307
  };

308
  DecodeFiles(files);
309
}
310
#endif  // CONFIG_WEBM_IO
311

312
INSTANTIATE_TEST_CASE_P(Synchronous, VPxWorkerThreadTest, ::testing::Bool());
313

314
}  // namespace