Lines Matching defs:program
33 std::vector<skvm::Instruction> program = b.program();
34 REPORTER_ASSERT(r, program.size() == 4);
36 program = skvm::eliminate_dead_code(program);
37 REPORTER_ASSERT(r, program.size() == 0);
41 // Let's build a program with no memory arguments.
49 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
51 program.eval(N);
120 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
126 program.eval(N, buf);
147 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
159 program.eval(20, &uniforms, buf);
201 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
217 program.eval(N, &uniforms, buf32, buf16, buf8);
259 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
279 program.eval(64, &uniforms, buf32, buf16, buf8);
312 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
314 program.eval(1, &x);
331 std::vector<skvm::OptimizedInstruction> program = b.optimize();
332 REPORTER_ASSERT(r, program.size() == 4);
333 REPORTER_ASSERT(r, program[0].op == skvm::Op::load32);
334 REPORTER_ASSERT(r, program[1].op == skvm::Op::neq_f32);
335 REPORTER_ASSERT(r, program[2].op == skvm::Op::bit_clear);
336 REPORTER_ASSERT(r, program[3].op == skvm::Op::store32);
338 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
343 program.eval(SK_ARRAY_COUNT(src), src, dst);
363 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
365 program.eval(SK_ARRAY_COUNT(buf), buf);
391 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
395 program.eval(SK_ARRAY_COUNT(in), in, out);
428 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
432 program.eval(SK_ARRAY_COUNT(in), in, out);
449 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
451 program.eval(SK_ARRAY_COUNT(buf), buf);
459 // This program is designed to exercise the tricky corners of instruction
474 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
476 program.eval(1, &x);
498 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
500 program.eval((int)SK_ARRAY_COUNT(buf), &buf);
520 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
522 program.eval((int)SK_ARRAY_COUNT(buf), &buf);
542 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
547 program.eval(1, &x);
559 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
562 program.eval(SK_ARRAY_COUNT(buf), buf);
579 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
584 program.eval(SK_ARRAY_COUNT(buf), buf, dst);
601 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
606 program.eval(SK_ARRAY_COUNT(d), s1, s2, d);
623 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
628 program.eval(SK_ARRAY_COUNT(d), s1, s2, d);
636 // This program uses enough constants that it will fail to JIT if we hoist them.
648 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
650 program.eval(1, &x);
669 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
671 program.eval(SK_ARRAY_COUNT(buf), buf);
681 // This program is the equivalent of
686 // One rescheduling of the program based only on data flow of Op arguments is
702 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
705 program.eval(SK_ARRAY_COUNT(b1), b1, b2);
737 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
758 program.eval(N, buf, &uniforms);
799 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
808 program.eval(K, uniforms.buf.data(), buf0, buf1, buf2);
820 program.eval(K, uniforms.buf.data(), buf0, buf1, buf2);
838 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
846 program.eval(K, buf);
855 // This little memset32() program should be able to JIT, but if we run that
861 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
864 program.eval(K, buf);
877 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
879 program.eval(SK_ARRAY_COUNT(buf), buf);
887 test_jit_and_interpreter(b, [&](const skvm::Program& program) {
889 program.eval(1);
2182 test_jit_and_interpreter(b, [&](const skvm::Program& program){
2186 program.eval(8, f,mn,mx, &f[i]);
2211 test_jit_and_interpreter(b, [&](const skvm::Program& program){
2213 program.eval(8, f,mn,mx);
2236 test_jit_and_interpreter(b, [&](const skvm::Program& program){
2238 program.eval(8, f,mn,mx);
2258 test_jit_and_interpreter(b, [&](const skvm::Program& program){
2260 program.eval(8, hs, dst);
2272 test_jit_and_interpreter(b, [&](const skvm::Program& program){
2274 program.eval(8, fs, dst);
2302 test_jit_and_interpreter(b, [&](const skvm::Program& program){
2304 program.eval(65, wide,l,h);
2320 test_jit_and_interpreter(b, [&](const skvm::Program& program){
2322 program.eval(65, w,lo,hi);
2350 test_jit_and_interpreter(b, [&](const skvm::Program& program){
2352 program.eval(63, packed, floats);
2369 test_jit_and_interpreter(b, [&](const skvm::Program& program){
2371 program.eval(63, floats, packed);
2389 test_jit_and_interpreter(b, [&](const skvm::Program& program){
2394 program.eval(8, bits, nan,fin);
2421 test_jit_and_interpreter(b, [&](const skvm::Program& program){
2426 program.eval(17, dst,A,B,C,D,E);
2450 test_jit_and_interpreter(p, [&](const skvm::Program& program){
2455 program.eval(17, uniforms,dst);
2540 // If we dedup the loads in this test program it will always increment by 1, not K.
2550 test_jit_and_interpreter(b, [&](const skvm::Program& program){
2552 program.eval(SK_ARRAY_COUNT(buf), buf);
2571 test_jit_and_interpreter(b, [&](const skvm::Program& program){
2573 program.eval(SK_ARRAY_COUNT(buf), buf);
2590 test_jit_and_interpreter(b, [&](const skvm::Program& program){
2599 program.eval(8,bits,fast,slow);