Allow explicit values naming

[tlemo]

Currently, the values are automatically "named" using a simple auto-incremented numeric id.

This means that using the C++ APIs allow meaningful names for C++ variables, but they will not match the IR names. At best, code ends up looking like this:

auto input_tv0 = makeDummyTensor(1);
auto exp_tv1 = unaryOp(UnaryOpType::Exp, input_tv0);
auto sum_exp_tv2 = sum(exp_tv1, {-1});
auto bcast_sum_tv3 = broadcast(sum_exp_tv2, {true});

One solution would be to allow setting explicit names for values. This would be optional (if not set explicitly we'd default to an auto-naming scheme like we do today).

An hypothetical solution which is backward compatible with the current API usage could look like this:

auto input = makeDummyTensor(1)->named("tv0");
auto exp = unaryOp(UnaryOpType::Exp, input_tv0)->named("tv1");
auto sum_exp = sum(exp_tv1, {-1})->named("tv2");
auto bcast_sum = broadcast(sum_exp_tv2, {true})->named("tv3");

[tlemo]

A few more notes:

1. We'll likely want to define (and enforce?) some rules on names. Matching C++ identifier rules seems and obvious choice since we use the names in the generated CUDA C++ code.

2. The names should be unique within a defined namespace. Whether we have a single "global" namespace per Fusion or multiple scopes is something to consider.

3. Having explicit names would allow another way of identifying nodes in the IR: lookup by name (right now it's just C++ pointers). This might come in handy for non-C++ APIs (ex. Python)

4. When we implement this we might want to consider extracting the "label generation" outside the Fusion (Statement) IR nodes.

[tlemo]

And a few ideas for C++ API notation options:

// option 1: explicit setName()
auto input = makeDummyTensor(1);
input->setName("input");
auto exp = unaryOp(UnaryOpType::Exp, input_tv0);
exp->setName("exp");
auto sum_exp = sum(exp_tv1, {-1});
sum_exp->setName("sum_exp");
auto bcast_sum = broadcast(sum_exp_tv2, {true});
bcast_sum->setName("bcast_sum");

// option 1b: explicit setName() wrapped in a macro (DRY)
auto input = makeDummyTensor(1);
TORCH_JIT_SET_IR_NAME(input);
auto exp = unaryOp(UnaryOpType::Exp, input_tv0);
TORCH_JIT_SET_IR_NAME(exp);
...

// option 2 
// (requires multiple T::named() definitions to preserve types)
auto input = makeDummyTensor(1)->named("input");
auto exp = unaryOp(UnaryOpType::Exp, input_tv0)->named("exp");
auto sum_exp = sum(exp_tv1, {-1})->named("exp_sum");
auto bcast_sum = broadcast(sum_exp_tv2, {true})->named("bcast_sum");

// option3
// (simpler implementation with the help of a named() function template)
auto input = named("input", makeDummyTensor(1));
auto exp = named("exp", unaryOp(UnaryOpType::Exp, input_tv0));
auto sum_exp = named("sum_exp", sum(exp_tv1, {-1}));
auto bcast_sum = named("bcast_sum", broadcast(sum_exp_tv2, {true}));

// either option, wrapped in a clever macro
TORCH_JIT_LET(input) = makeDummyTensor(1);
TORCH_JIT_LET(exp) = unaryOp(UnaryOpType::Exp, input_tv0);
TORCH_JIT_LET(sum_exp) = sum(exp_tv1, {-1});
TORCH_JIT_LET(bcast_sum) = broadcast(sum_exp_tv2, {true});

// either option, wrapped in a basic macro
TORCH_JIT_DEF(input, makeDummyTensor(1));
TORCH_JIT_DEF(exp, unaryOp(UnaryOpType::Exp, input_tv0));
TORCH_JIT_DEF(sum_exp, sum(exp_tv1, {-1}));
TORCH_JIT_DEF(bcast_sum, broadcast(sum_exp_tv2, {true}));