Polymorphic type in instance implementation

[yuyuranium]

Hi,

I'm designing a typeclass for any instruction type, which requires the type to implement 2 functions:

1. decode the instruction from any Bit#(ILen) value, and
2. execute the instruction on a given ExecContext interface.

The typeclass and the interface declaration looks like this:

interface ExecContext#(type data_t, type operand_t, type result_t);
  method operand_t#(data_t) opd1();
  method operand_t#(data_t) opd2();
  interface WriteOnly#(result_t#(data_t)) result;
endinterface

typeclass Instr#(type instr_t, numeric type ilen_t, type data_t, type operand_t, type result_t)
    dependencies (instr_t determines (ilen_t, data_t, operand_t, result_t));
  function instr_t decode(Bit#(ilen_t) raw);
  function Action execute(ExecContext#(data_t, operand_t, result_t) ctx, instr_t instr);
endtypeclass

Now I have an instruction type, Add, which implements this typeclass and is to operate over the vector type of Bit#(8) of any size:

typedef struct {
  Bool is_add;
} Add;

typedef 8 ILen;
typedef Bit#(8) Data;

instance Instr#(Add, ILen, Data, Vector#(n), Vector#(n));
  function Add decode(Bit#(ILen) raw);
    return Add { is_add: raw % 2 == 0 };  // Example decode
  endfunction

  function Action execute(ExecContext#(Data, Vector#(n), Vector#(n)) ctx, Add instr) = (action
    if (instr.is_add) begin
      ctx.result <= zipWith(add, ctx.opd1(), ctx.opd2());
    end
  endaction);
endinstance

Note that I used partial application for the type Vector, by passing only the size argument, n, which is a polymorphic type. This way, the operand_t#(data_t) becomes Vector#(n, data_t). The reason for this is that I can typedef t Scalar#(type t);, and by passing Scalar, operand_t#(data_t) becomes data_t.

However, when using the decode function, it reports that "Bit vector of unknown size introduced near this location."

module mkFoo ();
  Add a = decode(0);  // <--- This line!
endmodule

The full error message is:

Error: "/path/to/Foo.bsv", line 35, column 11: (T0035)
  Bit vector of unknown size introduced near this location.
  Please remove unnecessary extensions, truncations and concatenations and/or
  provide more type information to resolve this ambiguity.

If I'm not taking it wrong, the I/O type for the decode function should be uniquely determined by the instance implementation and has nothing to do with the vector size n.

Nonetheless, it succeeds to execute if the vector size is specified explicitly.

module mkBar ();
  Add a = Add {is_add: True};
  // Add a = decode(0);  // <--- This still failed!

  ExecContext#(Data, Vector#(8), Vector#(8)) ctx = (interface ExecContext;
    method Vector#(8, Data) opd1 = map(fromInteger, genVector);
    method Vector#(8, Data) opd2 = map(fromInteger, genVector);
    interface WriteOnly result;
      method Action _write(Vector#(8, Data) result);
        $display("Result is: ", fshow(result));
      endmethod
    endinterface
  endinterface);

  rule r;
    execute(ctx, a);  // outputs "Result is: <V   0   2   4   6   8  10  12  14  >"
    $finish;
  endrule
endmodule

Could someone please advise me if I’m making a mistake in my approach or suggest a solution to this issue? Also, is it a good approach to include the operand_t and result_t in the typeclass declaration? Is there a solution to accomplish my goal of operating the instruction on vectors of any size? Any assistance you can provide would be greatly appreciated. Thank you in advance!

[yuyuranium]

Furthermore, the Scalar version doesn’t appear to work either. 😢

typedef struct {
  Bool is_add;
} Add;

typedef 8 ILen;
typedef UInt#(8) Data;
typedef t Scalar#(type t);

instance Instr#(Add, ILen, Data, Scalar, Scalar);
  function Add decode(Bit#(ILen) raw);
    return Add { is_add: raw % 2 == 0 };  // Example decode
  endfunction

  function Action execute(ExecContext#(Data, Scalar, Scalar) ctx, Add instr) = (action
    if (instr.is_add) begin
      ctx.result <= ctx.opd1 + ctx.opd2;  // Scalar version of add
    end
  endaction);
endinstance

module mkBar ();
  Add a = Add {is_add: True};
  ExecContext#(Data, Scalar, Scalar) ctx = (interface ExecContext;
    method Scalar#(Data) opd1 = 1;
    method Scalar#(Data) opd2 = 2;
    interface WriteOnly result;
      method Action _write(Scalar#(Data) result);
        $display("Result is: ", fshow(result));
      endmethod
    endinterface
  endinterface);

  rule r;
    execute(ctx, a);  // expected output: "Result is: 3"
    $finish;
  endrule
endmodule

It reports an internal error:

Internal Bluespec Compiler Error:
Please report this failure to the BSC developers, by opening a ticket
in the issue database: https://github.com/B-Lang-org/bsc/issues
The following internal error message should be included in your
correspondence along with any other relevant details:
Bluespec Compiler, version no-git (build 0000000)
expandSyn,truncType
(1, 0, Foo.Instr Foo.Add Foo.ILen Foo.Data Foo.Scalar Foo.Scalar, (TGen 0))

[yuyuranium]

A solution to this issue is to separate the typeclass for the decode function and the execute function.

typeclass Decodable#(type instr_t, numeric type ilen_t)
    dependencies (instr_t determines ilen_t);
  function instr_t decode(Bit#(ilen_t) raw);
endtypeclass

typeclass Executable#(type instr_t, type ctx_t);
  function Action execute(ctx_t ctx, instr_t instr);
endtypeclass

typeclass Instr#(type instr_t, numeric type ilen_t, type ctx_t)
    provisos (Decodable#(instr_t, ilen_t),
              Executable#(instr_t, ctx_t))
    dependencies (instr_t determines (ilen_t, ctx_t));
endtypeclass

The implementation:

instance Decodable#(Add, ILen);
  function Add decode(Bit#(ILen) raw);
    return Add { is_add: raw % 2 == 0 };  // Example decode
  endfunction
endinstance

instance Executable#(Add, ExecContext#(Data, Vector#(n), Vector#(n)));
  function Action execute(ExecContext#(Data, Vector#(n), Vector#(n)) ctx, Add instr) = (action
    if (instr.is_add) begin
      ctx.result <= zipWith(add, ctx.opd1(), ctx.opd2());
    end
  endaction);
endinstance

instance Instr#(Add, ILen, ExecContext#(Data, Vector#(n), Vector#(n)));
endinstance

And the functions work as expected.

module mkBar ();
  Add a = decode(0);  // <--- this works!!
  ExecContext#(Data, Vector#(8), Vector#(8)) ctx = (interface ExecContext;
    method Vector#(8, Data) opd1 = map(fromInteger, genVector);
    method Vector#(8, Data) opd2 = map(fromInteger, genVector);
    interface WriteOnly result;
      method Action _write(Vector#(8, Data) result);
        $display("Result is: ", fshow(result));
      endmethod
    endinterface
  endinterface);

  rule r;
    execute(ctx, a);  // outputs "Result is: <V   0   2   4   6   8  10  12  14  >"
    $finish;
  endrule
endmodule

However, I still have no luck with the Scalar version.

[quark17]

You defined Scalar as a type synonym, not as a real type. That means it is like a macro, which can be inlined without changing the meaning of the code. That also means that it needs to be fully applied, can't be partially applied. BSC should have reported an error about the partial application, instead of an internal error. That is already open as Issue #221. (If you get an internal error, you can search for keywords from it, to see if there's an Issue or Discussion already open about it. For example, if you search for expandSyn or truncType, it brings up issue #221.)

The reason why you got a "vector of unknown size" error is because this instance is invalid:

instance Instr#(Add, ILen, Data, Vector#(n), Vector#(n));

As you said, the type Add should uniquely determine the other types. But Vector#(n) is not unique, it has a variable, which can be any number of different types. BSC should have reported an error about this instance; instead, BSC allowed it and later encountered the problem of a variable n that was not determined.

I don't fully understand what you're doing with the typeclasses, so I'm not sure I can recommend how else to write it. For example, I'm unclear why the type of the operand and result depend on the instruction. If they weren't part of the typeclass variables, then you wouldn't have this problem -- for example:

typeclass Instr#(type instr_t, numeric type ilen_t)
    dependencies (instr_t determines ilen_t);
  function instr_t decode(Bit#(ilen_t) raw);
  function Action execute(ExecContext#(data_t, operand_t, result_t) ctx, instr_t instr);
endtypeclass

Provisos on the instance could be used to require that Arith is available for the type operand_t, say-- and you could define Arith for Vector. Or just always use Vector and use 1 to indicate a scalar:

typeclass Instr#(type instr_t, numeric type ilen_t, numeric type sz)
    dependencies (instr_t determines ilen_t);
  function instr_t decode(Bit#(ilen_t) raw);
  function Action execute(ExecContext#(data_t, Vector#(sz, operand_t), Vector#(sz, result_t)) ctx, instr_t instr);

Or, use List if the length doesn't matter. Or use a new typeclass to indicate the set of allowed types.

[yuyuranium]

Thanks for your explanation! I’ve removed the operand and result types from the typeclass variables, and it works perfectly. Additionally, I’ve revised the ExecContext to avoid using something like operand_t#(data_t). Instead, I use operand_t and provide Vector#(n, data_t) for vectors and data_t for scalars. Now, this shouldn’t be a problem anymore! Thanks again for your assistance!