void test_lib__core__util_c()
{
subtest("parse_proxy_line", test_parse_proxy_line);
subtest("extract_push_path_from_link_header", test_extract_push_path_from_link_header);
subtest("test_build_destination", test_build_destination);
subtest("test_build_destination_escaping", test_build_destination_escaping);
}
void
piglit_init(int argc, char **argv)
{
enum piglit_result status = PIGLIT_PASS;
const struct image_stage_info *stage;
piglit_require_extension("GL_ARB_shader_image_load_store");
for (stage = image_stages(); stage->name; ++stage) {
subtest(&status, true,
run_test(stage->bit),
"%s shader max image uniforms test",
stage->name);
}
subtest(&status, true,
run_test((get_image_stage(GL_VERTEX_SHADER) ?
GL_VERTEX_SHADER_BIT : 0) |
(get_image_stage(GL_TESS_CONTROL_SHADER) ?
GL_TESS_CONTROL_SHADER_BIT : 0) |
(get_image_stage(GL_TESS_EVALUATION_SHADER) ?
GL_TESS_EVALUATION_SHADER_BIT : 0) |
(get_image_stage(GL_GEOMETRY_SHADER) ?
GL_GEOMETRY_SHADER_BIT : 0) |
GL_FRAGMENT_SHADER_BIT),
"Combined max image uniforms test");
piglit_report_result(status);
}
int main(int argc, char **argv)
{
subtest("request", test_request);
subtest("response", test_response);
subtest("headers", test_headers);
subtest("chunked", test_chunked);
subtest("chunked-consume-trailer", test_chunked_consume_trailer);
return done_testing();
}
void test_lib__common__string_c(void)
{
subtest("strstr", test_strstr);
subtest("stripws", test_stripws);
subtest("get_filext", test_get_filext);
subtest("next_token", test_next_token);
subtest("next_token2", test_next_token2);
subtest("next_token3", test_next_token3);
subtest("decode_base64", test_decode_base64);
subtest("htmlescape", test_htmlescape);
subtest("uri_escape", test_uri_escape);
subtest("at_position", test_at_position);
}
void
piglit_init(int argc, char **argv)
{
enum piglit_result status = PIGLIT_PASS;
piglit_require_extension("GL_ARB_shader_image_load_store");
subtest(&status, true, run_test_binding(),
"binding state test");
subtest(&status, true, run_test_uniform(),
"uniform state test");
piglit_report_result(status);
}
void
piglit_init(int argc, char **argv)
{
enum piglit_result status = PIGLIT_PASS;
const struct image_format_info *format;
unsigned i;
piglit_require_extension("GL_ARB_shader_image_load_store");
for (format = image_formats_load_store; format->name; ++format) {
for (i = 0; i < 8; ++i) {
const bool strict_layout_qualifiers = i & 1;
const bool strict_access_qualifiers = i & 2;
const bool strict_binding = i & 4;
subtest(&status, true,
run_test(format, strict_layout_qualifiers,
strict_access_qualifiers,
strict_binding),
"%s/%s layout qualifiers/%s access qualifiers/"
"%s binding test", format->name,
(strict_layout_qualifiers ? "strict" : "permissive"),
(strict_access_qualifiers ? "strict" : "permissive"),
(strict_binding ? "strict" : "permissive"));
}
}
piglit_report_result(status);
}
void
piglit_init(int argc, char **argv)
{
const bool quick = (argc >= 2 && !strcmp(argv[1], "--quick"));
enum piglit_result status = PIGLIT_PASS;
const struct image_target_info *target;
int d;
piglit_require_extension("GL_ARB_shader_image_load_store");
for (target = image_targets(); target->name; ++target) {
for (d = 0; d < 4; ++d) {
if (should_test_dimension(target, d)) {
const struct image_extent size =
get_test_extent(target, d);
subtest(&status,
is_test_reasonable(quick, size),
run_test(target, size),
"image%s max size test/%dx%dx%dx%d",
target->name,
size.x, size.y, size.z, size.w);
}
}
}
piglit_report_result(status);
}
void
piglit_init(int argc, char **argv)
{
enum piglit_result status = PIGLIT_PASS;
const struct image_op_info *op;
piglit_require_extension("GL_ARB_shader_image_load_store");
for (op = image_ops; op->name; ++op) {
/*
* Draw a rectangle discarding a subset of the
* fragments before inc() is run, then make sure that
* it had no effect for those fragments.
*/
subtest(&status, true,
run_test(op, W, H, check_discard,
"GRID_T op(ivec2 idx, GRID_T x) {\n"
" if (idx.x % 5 == 0)\n"
" discard;\n"
" inc(idx);\n"
" return x;\n"
"}\n"),
"%s/discard test", op->name);
/*
* Draw a 1-pixel wide rectangle and make a derivative
* computation in the orthogonal direction to get the
* GPU to run fragment shader invocations located
* outside the primitive, then make sure that inc()
* had no effect for those fragments.
*/
subtest(&status, true,
run_test(op, W - 3, 1, check_derivative,
"GRID_T op(ivec2 idx, GRID_T x) {\n"
" x = uvec4(1000 * dFdy(vec4("
" imageLoad(img, IMAGE_ADDR(idx)))));"
" inc(idx);\n"
" return x;\n"
"}\n"),
"%s/derivative test", op->name);
}
piglit_report_result(status);
}
void
piglit_init(int argc, char **argv)
{
enum piglit_result status = PIGLIT_PASS;
const struct image_target_info *target;
piglit_require_extension("GL_ARB_shader_image_load_store");
for (target = image_targets(); target->name; ++target) {
subtest(&status, true,
run_test(target, false, 5),
"image%s/non-layered binding test", target->name);
subtest(&status, true,
run_test(target, true, 5),
"image%s/layered binding test", target->name);
}
piglit_report_result(status);
}
void
piglit_init(int argc, char **argv)
{
const struct image_qualifier_info *qual;
enum piglit_result status = PIGLIT_PASS;
piglit_require_extension("GL_ARB_shader_image_load_store");
for (qual = image_qualifiers; qual->name; ++qual) {
subtest(&status, true, run_test(qual),
"%s image aliasing test", qual->name);
}
piglit_report_result(status);
}
void test_lib__handler__fastcgi_c()
{
h2o_globalconf_t globalconf;
h2o_hostconf_t *hostconf;
h2o_pathconf_t *pathconf;
h2o_config_init(&globalconf);
globalconf.server_name = h2o_iovec_init(H2O_STRLIT("h2o/1.2.1-alpha1"));
hostconf = h2o_config_register_host(&globalconf, h2o_iovec_init(H2O_STRLIT("default")), 65535);
pathconf = h2o_config_register_path(hostconf, "/");
h2o_context_init(&ctx, test_loop, &globalconf);
subtest("build-request", test_build_request);
h2o_context_dispose(&ctx);
h2o_config_dispose(&globalconf);
}
void
piglit_init(int argc, char **argv)
{
const bool quick = (argc >= 2 && !strcmp(argv[1], "--quick"));
const struct image_qualifier_info *qual;
const struct image_stage_info *stage_w;
const struct image_stage_info *stage_r;
enum piglit_result status = PIGLIT_PASS;
unsigned l;
piglit_require_extension("GL_ARB_shader_image_load_store");
for (l = 4; l <= L; l *= (quick ? 8 : 2)) {
for (qual = image_qualifiers; qual->name; ++qual) {
if (quick && qual->control_test)
continue;
/*
* Loop for each pair of shader stages
* skipping the compute shader: "coherent"
* gives no useful guarantees in that case
* since its execution ordering is undefined
* with respect to the other shader stages.
*/
for (stage_w = image_stages();
stage_w->stage; ++stage_w) {
for (stage_r = stage_w + 1;
stage_r->stage; ++stage_r) {
if (stage_w->stage == GL_COMPUTE_SHADER ||
stage_r->stage == GL_COMPUTE_SHADER)
continue;
subtest(&status, true,
run_test(qual, stage_w, stage_r, l),
"%s-%s shader/%s coherency test/%dx%d",
stage_w->name, stage_r->name,
qual->name, l, l);
}
}
}
}
piglit_report_result(status);
}
int main(int argc, char **argv)
{
ERR_load_crypto_strings();
OpenSSL_add_all_algorithms();
#if !defined(OPENSSL_NO_ENGINE)
/* Load all compiled-in ENGINEs */
ENGINE_load_builtin_engines();
ENGINE_register_all_ciphers();
ENGINE_register_all_digests();
#endif
{
BIO *bio = BIO_new_mem_buf(RSA_CERTIFICATE, strlen(RSA_CERTIFICATE));
X509 *x509 = PEM_read_bio_X509(bio, NULL, NULL, NULL);
assert(x509 != NULL || !!"failed to load certificate");
BIO_free(bio);
cert.len = i2d_X509(x509, &cert.base);
X509_free(x509);
}
{
BIO *bio = BIO_new_mem_buf(RSA_PRIVATE_KEY, strlen(RSA_PRIVATE_KEY));
EVP_PKEY *pkey = PEM_read_bio_PrivateKey(bio, NULL, NULL, NULL);
assert(pkey != NULL || !"failed to load private key");
BIO_free(bio);
ptls_openssl_init_sign_certificate(&cert_signer, pkey);
EVP_PKEY_free(pkey);
}
subtest("next-packet-number", test_next_packet_number);
subtest("ranges", test_ranges);
subtest("frame", test_frame);
subtest("maxsender", test_maxsender);
subtest("ack", test_ack);
subtest("simple", test_simple);
subtest("stream-concurrency", test_stream_concurrency);
subtest("loss", test_loss);
return done_testing();
}
int main(int argc, char **argv)
{
ptls_openssl_sign_certificate_t openssl_sign_certificate;
ptls_openssl_verify_certificate_t openssl_verify_certificate;
ERR_load_crypto_strings();
OpenSSL_add_all_algorithms();
#if !defined(OPENSSL_NO_ENGINE)
/* Load all compiled-in ENGINEs */
ENGINE_load_builtin_engines();
ENGINE_register_all_ciphers();
ENGINE_register_all_digests();
#endif
ptls_iovec_t cert;
setup_certificate(&cert);
setup_sign_certificate(&openssl_sign_certificate);
ptls_openssl_init_verify_certificate(&openssl_verify_certificate, NULL);
ptls_context_t openssl_ctx = {
ptls_openssl_random_bytes, ptls_openssl_key_exchanges, ptls_openssl_cipher_suites, {&cert, 1}, NULL, NULL,
&openssl_sign_certificate.super, &openssl_verify_certificate.super};
ctx = ctx_peer = &openssl_ctx;
subtest("ecdh-key-exchange", test_ecdh_key_exchange);
subtest("rsa-sign", test_rsa_sign);
subtest("ecdsa-sign", test_ecdsa_sign);
subtest("picotls", test_picotls);
ptls_minicrypto_secp256r1sha256_sign_certificate_t minicrypto_sign_certificate;
ptls_iovec_t minicrypto_certificate = ptls_iovec_init(SECP256R1_CERTIFICATE, sizeof(SECP256R1_CERTIFICATE) - 1);
ptls_minicrypto_init_secp256r1sha256_sign_certificate(
&minicrypto_sign_certificate, ptls_iovec_init(SECP256R1_PRIVATE_KEY, sizeof(SECP256R1_PRIVATE_KEY) - 1));
ptls_context_t minicrypto_ctx = {ptls_minicrypto_random_bytes,
ptls_minicrypto_key_exchanges,
ptls_minicrypto_cipher_suites,
{&minicrypto_certificate, 1},
NULL,
NULL,
&minicrypto_sign_certificate.super};
ctx_peer = &minicrypto_ctx;
subtest("vs. minicrypto", test_picotls);
ctx = &minicrypto_ctx;
ctx_peer = &openssl_ctx;
subtest("minicrypto vs.", test_picotls);
return done_testing();
}
int main(int argc, char** argv)
{
if ((argc > 2) || ((argc == 2) && (strcmp(argv[1], "master") != 0)))
{
cerr << "Usage: " << argv[0] << " master - start the tests" << endl;
cerr << " " << argv[0] << " - run a subtest" << endl;
exit(1);
}
if (argc == 2)
{
master(argv[0]);
cout << argv[0] << " +++++ passed all tests" << endl;
}
else
{
subtest();
}
return 0;
}
void test_lib__http2__cache_digests(void)
{
subtest("calc_hash", test_calc_hash);
subtest("test_decode", test_decode);
}
void test_PASS(int syscall) {
int child;
subtest("intercept");
do_intercept(syscall, 0);
do_release(syscall, 0);
subtest("monitor");
do_intercept(syscall, 0);
test_monitor(syscall, FALSE);
do_start(syscall, -1, 0);
test_monitor(syscall, TRUE);
do_stop(syscall, -1, 0);
test_monitor(syscall, FALSE);
do_release(syscall, 0);
subtest("monitor & kill monitored process");
do_intercept(syscall, 0);
switch (child = fork()) {
case -1:
assert(0);
case 0:
// monitor the child process then exit
do_start(syscall, -1, 0);
test_monitor(syscall, TRUE);
exit(0);
default:
waitpid(child, NULL, 0);
// child should have been unmonitored automatically
// there is no way to start process with specific pid...
do_start(syscall, child, -EINVAL);
do_stop(syscall, child, -EINVAL);
}
do_release(syscall, 0);
subtest("monitor all pids");
do_intercept(syscall, 0);
test_monitor2(syscall, FALSE, FALSE);
do_start(syscall, 0, 0);
test_monitor2(syscall, TRUE, TRUE);
subtest("stop monitor current pid");
do_stop(syscall, -1, 0);
test_monitor2(syscall, FALSE, TRUE);
subtest("monitor all -> stop one -> monitor all");
do_start(syscall, 0, 0);
do_stop(syscall, -1, 0);
do_start(syscall, 0, 0);
do_stop(syscall, 0, 0);
subtest("monitor one -> stop all");
do_start(syscall, -1, 0);
do_stop(syscall, 0, 0);
subtest("monitor all -> stop one -> stop all");
do_start(syscall, 0, 0);
do_stop(syscall, -1, 0);
do_stop(syscall, 0, 0);
subtest("reset");
do_start(syscall, -1, 0);
test_monitor2(syscall, TRUE, FALSE);
do_stop(syscall, 0, 0);
test_monitor2(syscall, FALSE, FALSE);
do_release(syscall, 0);
}
void test_CDE(int syscall) {
//C -EINVAL
subtest("Cannot de-intercept a system call that has not been intercepted yet.");
do_release(syscall, -EINVAL);
subtest("Cannot stop monitoring a pid for a syscall that has not been intercepted.");
do_stop(syscall, -1, -EINVAL);
do_stop(syscall, 0, -EINVAL);
subtest("Cannot start monitoring a pid for that has not been intercepted yet.");
do_start(syscall, -1, -EINVAL);
do_start(syscall, 0, -EINVAL);
do_intercept(syscall, 0);
subtest("Cannot start monitoring a pid that is invalid.");
do_start(syscall, 1234567, -EINVAL);
do_start(syscall, -2, -EINVAL);
subtest("Cannot stop monitoring for a pid that is not being monitored.");
do_stop(syscall, 0, -EINVAL);
do_stop(syscall, -1, -EINVAL);
subtest("Cannot stop monitoring for a pid that is blacklisted.");
do_start(syscall, 0, 0);
do_stop(syscall, -1, 0);
do_stop(syscall, -1, -EINVAL);
do_stop(syscall, 0, 0);
subtest("EINVAL: stop all -> stop all");
do_start(syscall, 0, 0);
do_stop(syscall, 0, 0);
do_stop(syscall, 0, -EINVAL);
subtest("EINVAL: start one pid -> stop the same pid -> stop all");
do_start(syscall, -1, 0);
do_stop(syscall, -1, 0);
do_stop(syscall, 0, -EINVAL);
do_release(syscall, 0);
//D -EBUSY
do_intercept(syscall, 0);
subtest("EBUSY: intercepting a system call that is already intercepted");
do_intercept(syscall, -EBUSY);
subtest("EBUSY: monitoring a pid that is being whitelisted");
do_start(syscall, -1, 0);
do_start(syscall, -1, -EBUSY);
do_stop(syscall, -1, 0);
subtest("EBUSY: monitoring a pid that is being monitored globally");
do_start(syscall, 0, 0);
do_start(syscall, -1, -EBUSY);
do_stop(syscall, 0, 0);
subtest("EBUSY: monitoring all pids when all pids are being monitored");
do_start(syscall, 0, 0);
do_start(syscall, 0, -EBUSY);
do_stop(syscall, 0, 0);
subtest("OK: monitoring all pids when some pids are being monitored");
do_start(syscall, -1, 0);
do_start(syscall, 0, 0);
do_stop(syscall, -1, 0);
do_stop(syscall, 0, 0);
//E -ENOMEM
//If a pid cannot be added to a monitored list, due to no memory being available, an -ENOMEM error code should be returned.
// int child;
// int res = 0;
// while (!res) {
// switch (child = fork()) {
// case -1://error
// assert(0);
// case 0: //child
// pause();
// default: //parent
// res = vsyscall_arg(MY_CUSTOM_SYSCALL, 3, REQUEST_START_MONITORING, syscall, child);
// // printf("start monitoring %d: %d\n", child, res);
// break;
// }
// }
// test("%d no memory", syscall, res == -ENOMEM);
// signal(SIGQUIT, SIG_IGN);
// kill(-getpid(), SIGQUIT);
do_release(syscall, 0);
}
void test_lib__common__hostinfo_c(void)
{
/* TODO add tests for h2o_hostinfo_getaddr and related */
subtest("aton", test_aton);
}
void
piglit_init(int argc, char **argv)
{
enum piglit_result status = PIGLIT_PASS;
piglit_require_extension("GL_ARB_shader_image_load_store");
subtest(&status, true,
run_test(0, 33,
"GRID_T op(ivec2 idx, GRID_T x) {\n"
" imageAtomicAdd(img, IMAGE_ADDR(idx), BASE_T(33));\n"
" return x;\n"
"}\n"),
"imageAtomicAdd");
subtest(&status, true,
run_test(0xffffffff, 33,
"GRID_T op(ivec2 idx, GRID_T x) {\n"
" imageAtomicMin(img, IMAGE_ADDR(idx), BASE_T(33));\n"
" return x;\n"
"}\n"),
"imageAtomicMin");
subtest(&status, true,
run_test(0, 33,
"GRID_T op(ivec2 idx, GRID_T x) {\n"
" imageAtomicMax(img, IMAGE_ADDR(idx), BASE_T(33));\n"
" return x;\n"
"}\n"),
"imageAtomicMax");
subtest(&status, true,
run_test(0xffffffff, 33,
"GRID_T op(ivec2 idx, GRID_T x) {\n"
" imageAtomicAnd(img, IMAGE_ADDR(idx), BASE_T(33));\n"
" return x;\n"
"}\n"),
"imageAtomicAnd");
subtest(&status, true,
run_test(0, 33,
"GRID_T op(ivec2 idx, GRID_T x) {\n"
" imageAtomicOr(img, IMAGE_ADDR(idx), BASE_T(33));\n"
" return x;\n"
"}\n"),
"imageAtomicOr");
subtest(&status, true,
run_test(0, 33,
"GRID_T op(ivec2 idx, GRID_T x) {\n"
" imageAtomicXor(img, IMAGE_ADDR(idx), BASE_T(33));\n"
" return x;\n"
"}\n"),
"imageAtomicXor");
subtest(&status, true,
run_test(0, 33,
"GRID_T op(ivec2 idx, GRID_T x) {\n"
" imageAtomicExchange(img, IMAGE_ADDR(idx),"
" BASE_T(33));\n"
" return x;\n"
"}\n"),
"imageAtomicExchange");
subtest(&status, true,
run_test(0, 33,
"GRID_T op(ivec2 idx, GRID_T x) {\n"
" imageAtomicCompSwap(img, IMAGE_ADDR(idx),"
" BASE_T(0), BASE_T(33));\n"
" return x;\n"
"}\n"),
"imageAtomicCompSwap");
piglit_report_result(status);
}
void test_maxsender(void)
{
subtest("basic", test_basic);
subtest("stream-id", test_stream_id);
}
void
piglit_init(int argc, char **argv)
{
enum piglit_result status = PIGLIT_PASS;
piglit_require_extension("GL_ARB_shader_image_load_store");
/*
* If imageAtomicAdd() is atomic the return values obtained
* from each call are guaranteed to be unique.
*/
subtest(&status, true,
run_test(0, 1, N, true,
"GRID_T op(ivec2 idx, GRID_T x) {\n"
" return GRID_T("
" imageAtomicAdd(img, IMAGE_ADDR(ivec2(0)), 1u),"
" 0, 0, 1);\n"
"}\n"),
"imageAtomicAdd");
/*
* Call imageAtomicMin() on a fixed location from within a
* loop passing the most recent guess of the counter value
* decremented by one.
*
* If no race occurs the counter will be decremented by one
* and we're done, if another thread updates the counter in
* parallel imageAtomicMin() has no effect since
* min(x-n, x-1) = x-n for n >= 1, so we update our guess and
* repeat. In the end we obtain a unique counter value for
* each fragment if the read-modify-write operation is atomic.
*/
subtest(&status, true,
run_test(0xffffffff, 1, 0xffffffff - N, true,
"GRID_T op(ivec2 idx, GRID_T x) {\n"
" uint old, v = 0xffffffffu;"
"\n"
" do {\n"
" old = v;\n"
" v = imageAtomicMin(img, IMAGE_ADDR(ivec2(0)),"
" v - 1u);\n"
" } while (v != old);\n"
"\n"
" return GRID_T(v, 0, 0, 1);\n"
"}\n"),
"imageAtomicMin");
/*
* Use imageAtomicMax() on a fixed location to increment a
* counter as explained above for imageAtomicMin(). The
* atomicity of the built-in guarantees that the obtained
* values will be unique for each fragment.
*/
subtest(&status, true,
run_test(0, 1, N, true,
"GRID_T op(ivec2 idx, GRID_T x) {\n"
" uint old, v = 0u;"
"\n"
" do {\n"
" old = v;\n"
" v = imageAtomicMax(img, IMAGE_ADDR(ivec2(0)),"
" v + 1u);\n"
" } while (v != old);\n"
"\n"
" return GRID_T(v, 0, 0, 1);\n"
"}\n"),
"imageAtomicMax");
/*
* Use imageAtomicAnd() to flip individual bits of a bitmap
* atomically. The atomicity of the built-in guarantees that
* all bits will be clear on termination.
*/
subtest(&status, true,
run_test(0xffffffff, N / 32, 0, false,
"GRID_T op(ivec2 idx, GRID_T x) {\n"
" int i = IMAGE_ADDR(idx);\n"
" uint m = ~(1u << (i % 32));\n"
"\n"
" imageAtomicAnd(img, i / 32, m);\n"
"\n"
" return GRID_T(0, 0, 0, 1);\n"
"}\n"),
"imageAtomicAnd");
/*
* Use imageAtomicOr() to flip individual bits of a bitmap
* atomically. The atomicity of the built-in guarantees that
* all bits will be set on termination.
*/
subtest(&status, true,
run_test(0, N / 32, 0xffffffff, false,
"GRID_T op(ivec2 idx, GRID_T x) {\n"
" int i = IMAGE_ADDR(idx);\n"
" uint m = (1u << (i % 32));\n"
"\n"
" imageAtomicOr(img, i / 32, m);\n"
"\n"
" return GRID_T(0, 0, 0, 1);\n"
"}\n"),
"imageAtomicOr");
/*
* Use imageAtomicXor() to flip individual bits of a bitmap
* atomically. The atomicity of the built-in guarantees that
* all bits will have been inverted on termination.
*/
subtest(&status, true,
run_test(0x55555555, N / 32, 0xaaaaaaaa, false,
"GRID_T op(ivec2 idx, GRID_T x) {\n"
" int i = IMAGE_ADDR(idx);\n"
" uint m = (1u << (i % 32));\n"
"\n"
" imageAtomicXor(img, i / 32, m);\n"
"\n"
" return GRID_T(0, 0, 0, 1);\n"
"}\n"),
"imageAtomicXor");
/*
* Use imageAtomicExchange() to flip individual bits of a
* bitmap atomically. The atomicity of the built-in
* guarantees that all bits will be set on termination.
*/
subtest(&status, true,
run_test(0, N / 32, 0xffffffff, false,
"GRID_T op(ivec2 idx, GRID_T x) {\n"
" int i = IMAGE_ADDR(idx);\n"
" uint m = (1u << (i % 32));\n"
" uint old = 0u;\n"
"\n"
" do {\n"
" m |= old;\n"
" old = imageAtomicExchange("
" img, i / 32, m);\n"
" } while ((old & ~m) != 0u);\n"
"\n"
" return GRID_T(0, 0, 0, 1);\n"
"}\n"),
"imageAtomicExchange");
#if 0
/*
* Use imageAtomicExchange() on a fixed location to increment
* a counter, implementing a sort of spin-lock.
*
* The counter has two states: locked (0xffffffff) and
* unlocked (any other value). While locked a single thread
* owns the value of the counter, increments its value and
* puts it back to the same location, atomically releasing the
* counter. The atomicity of the built-in guarantees that the
* obtained values will be unique for each fragment.
*
* Unlike the classic spin-lock implementation, this uses the
* same atomic call to perform either a lock or an unlock
* operation depending on the current thread state. This is
* critical to avoid a dead-lock situation on machines where
* neighboring threads have limited parallelism (e.g. share
* the same instruction pointer).
*
* This could lead to a different kind of dead-lock on devices
* that simulate concurrency by context-switching threads
* based on some sort of priority queue: If there is a
* possibility for a low-priority thread to acquire the lock
* and be preempted before the end of the critical section, it
* will prevent higher priority threads from making progress
* while the higher priority threads may prevent the
* lock-owning thread from being scheduled again and releasing
* the lock.
*
* Disabled for now because the latter dead-lock can easily be
* reproduced on current Intel hardware where it causes a GPU
* hang. It seems to work fine on nVidia though, it would be
* interesting to see if it works on other platforms.
*/
subtest(&status, true,
run_test(0, 1, N, true,
"GRID_T op(ivec2 idx, GRID_T x) {\n"
" uint p = 0xffffffffu, v = 0xffffffffu;\n"
"\n"
" do {\n"
" if (p != 0xffffffffu)\n"
" v = p++;\n"
" p = imageAtomicExchange("
" img, IMAGE_ADDR(ivec2(0)), p);\n"
" } while (v == 0xffffffffu);\n"
"\n"
" return GRID_T(v, 0, 0, 1);\n"
"}\n"),
"imageAtomicExchange (locking)");
#endif
/*
* Use imageAtomicCompSwap() on a fixed location from within a
* loop passing the most recent guess of the counter value as
* comparison value and the same value incremented by one as
* argument. The atomicity of the built-in guarantees that
* the obtained values will be unique for each fragment.
*/
subtest(&status, true,
run_test(0, 1, N, true,
"GRID_T op(ivec2 idx, GRID_T x) {\n"
" uint old, v = 0u;"
"\n"
" do {\n"
" old = v;\n"
" v = imageAtomicCompSwap("
" img, IMAGE_ADDR(ivec2(0)), v, v + 1u);\n"
" } while (v != old);\n"
"\n"
" return GRID_T(v, 0, 0, 1);\n"
"}\n"),
"imageAtomicCompSwap");
piglit_report_result(status);
}
void test_lib__core__util_c()
{
subtest("parse_proxy_line", test_parse_proxy_line);
subtest("extract_push_path_from_link_header", test_extract_push_path_from_link_header);
}
