Multiplication in Brainfuck - minimum number of evaluations

Question

Given two numbers in tape location #0 and tape location #1 in Brainfuck, compute their product into another tape location (specify with answer). Optimize for the least amount of time-units used, where the interpretation of any command uses one time-unit. As example, here is a quick C++ program to determine the number of time-units used by a Brainfuck program:

#include <iostream>
#include <fstream>
#include <stack>
#include <algorithm>
#define MEMORY 10000
#define DATATYPE uint32_t
#define ALWAYSPOSITIVE true

DATATYPE tape[MEMORY];
int loc, instp;

int main(int argc, char* argv[]) {
    std::string infile = "a.bf";
    bool numeric = false;
    bool debug = false;
    std::string flag;
    for(int i=1; i<argc; i++) {
        std::string arg = argv[i];
        if(arg[0] == '-') flag = arg;
        else {
            if(flag == "-i" || flag == "--in") infile = arg;
        }

        if(flag == "-n" || flag == "--numeric") numeric = true; 
        if(flag == "-d" || flag == "--debug") debug = true;
    }
    if(infile == "") {
        std::cerr << "Fatal: no input file specified. Usage: ./pp2bf -i <file> [-n] [-d]" << std::endl;
        return 1;
    }
    std::ifstream progf(infile);
    std::string prog; std::string line;
    std::stack<int> loop;
    while(progf >> line) prog += line;
    instp = 0; uint64_t instc = 0, ptmove = 0, mchange = 0;
    int maxaccessedmem = 0;
    while(instp != prog.size()) {
        char inst = prog[instp];
        if(debug) {
            std::cout << inst << " #" << instp << " @" << loc;
            for(int i=0; i<=maxaccessedmem; i++)
                std::cout << " " << tape[i];
            std::cout << "\n";
        }
        if(inst == '[') {
            if(!tape[loc]) { // automatically advance to matching ]
                int n = 1;
                for(int i=instp+1;;i++) {
                    if(prog[i] == '[') n++;
                    if(prog[i] == ']') n--;
                    if(n == 0) {
                        instp = i+1;
                        break;
                    }
                }
                continue;
            }
            loop.push(instp);
        } else if(inst == ']') {
            if(tape[loc]) {
                instp = loop.top() + 1;
                continue;
            } else {
                loop.pop();
            }
        } else if(inst == '>') {
            loc++;
            maxaccessedmem = std::max(maxaccessedmem, loc);
            ptmove++;
            if(loc == MEMORY) {
                std::cerr << "Fatal: Pointer out of bounds (try increasing memory) @ instruction " << instp << std::endl;
                return 1;
            }
        } else if(inst == '<') {
            loc--;
            ptmove++;
            if(loc == -1) {
                std::cerr << "Fatal: Pointer out of bounds @ instruction " << instp << std::endl;
                return 1;
            }
        } else if(inst == '+') {
            mchange++;
            tape[loc]++;
        } else if(inst == '-') {
            mchange++;
            if(tape[loc] == 0) {
                if(ALWAYSPOSITIVE) {
                    std::cerr << "Fatal: Negative tape value at " << loc << " @ instruction " << instp << std::endl;
                    return 1;
                } else {
                    std::cerr << "Warning: Tape value at " << loc << " @ instruction " << instp << std::endl;
                }
            }
            tape[loc]--;
        } else if(inst == '.') {
            mchange++;
            if(numeric) {
                std::cout << (DATATYPE)(tape[loc]) << std::endl;
            } else {
                std::cout << (char)(tape[loc]);
            }
        } else if(inst == ',') {
            mchange++;
            if(numeric) {
                int inp; std::cin >> inp;
                tape[loc] = inp;
            } else {
                char inp; std::cin >> inp;
                tape[loc] = inp;
            }
        }
        instp++;
        instc++;
    }
    std::cout << "\nTerminated after " << instc << " time-units." << \
                 "\nMoved pointer " << ptmove << " times." << \
                 "\nChanged a memory location " << mchange << " times." << std::endl;
}

Note: In this implementation the tape is allotted 10K locations and each tape is an unsigned 32-bit integer - not the 8 bits used in a standard Brainfuck implementation.

For starters, here's mine:

,>,[<[>>+>+<<<-]>>>[<<<+>>>-]<<-]>.<<

When you compile the C++ program as rbf, save the Brainfuck program as mult.bf, run ./rbf -i mult.bf -n, and type 1000 followed by pressing Enter twice, the following output appears:

1000000

Terminated after 17011009 time-units.
Moved pointer 12006004 times.
Changed a memory location 5001003 times.

Your goal is to minimize the first value (i.e. 17011009). In case of ties minimize the second (12006004) and then the third (5001003).

The standard test case is

1000
1000

However, your code shouldn't be optimized for this test case only, but expend minimal time-units for any two numbers.

EDIT: For well-formedness, and not hardcoding an answer, take the sum of the expended time units in all test cases

x
x

where x = 900...1000 inclusive to get the final time units expended.

Answer 1

7,009,011 timesteps for \$1000*1000\$

>>,>,[<[-<+<+>>]>-[<<[-<+>>+<]]>[>->]<]<<<.

Try It Online!

This increases the counter on both the initial transfer and the second transfer back to the original position. This makes it almost the same efficiency for both orderings of the input, for example, \$100*1000\$ is \$709011\$ steps, while \$1000*100\$ is \$700911\$ steps.

I'm not really sure I want to attempt calculating sum of the given test cases.