/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package unittest

import chisel3._
import chisel3.util._
import chiseltest._
import chiseltest.iotesters._
import unittest.util._
import vta.core._
import vta.util.config._

class TensorGemmTester(c: TensorGemmSimple) extends PeekPokeTester(c) {
  poke(c.io.start, 0)
  poke(c.io.dec.reset, 0)
  poke(c.io.dec.uop_begin, 0)
  poke(c.io.dec.uop_end, 1)
  poke(c.io.dec.lp_0, 1)
  poke(c.io.dec.lp_1, 1)
  poke(c.io.dec.acc_0, 1)
  poke(c.io.dec.acc_1, 1)
  poke(c.io.dec.inp_0, 1)
  poke(c.io.dec.inp_1, 1)
  poke(c.io.dec.wgt_0, 1)
  poke(c.io.dec.wgt_1, 1)
  // Don't need empty_0, {push, pop}_{next, prev}, op

  poke(c.io.uop.data.bits.u0, 0)
  poke(c.io.uop.data.bits.u1, 0)
  poke(c.io.uop.data.bits.u2, 0)

  val inp = IndexedSeq.fill(c.io.inp.rd(0).data.bits(0).size){BigInt(1)}
  for {lhs <- c.io.inp.rd(0).data.bits} {
    poke(lhs, inp.reverse)
  }

  val wgt = IndexedSeq.fill(c.io.wgt.rd(0).data.bits(0).size){BigInt(1)}
  for {lhs <- c.io.wgt.rd(0).data.bits} {
    poke(lhs, wgt.reverse)
  }

  val acc = IndexedSeq.fill(c.io.acc.rd(0).data.bits(0).size){BigInt(1)}
  for {lhs <- c.io.acc.rd(0).data.bits} {
    poke(lhs, acc.reverse)
  }

  class TensorMasterMock(tm: TensorMaster) {
    poke(tm.rd(0).data.valid, 0)
    var valid = peek(tm.rd(0).idx.valid)

    def logical_step(v: BigInt) {
      poke(tm.rd(0).data.valid, valid)
      valid = peek(tm.rd(0).idx.valid)
      expect(tm.rd(0).idx.valid, v)
    }
  }

  class UopMasterMock(um: UopMaster) {
    poke(um.data.valid, 0)
    var valid = peek(um.idx.valid)

    def logical_step(v: BigInt) {
      poke(um.data.valid, valid)
      valid = peek(um.idx.valid)
      expect(um.idx.valid, v)
    }
  }

  class Mocks {
    val uop_mock = new UopMasterMock(c.io.uop)
    val inp_mock = new TensorMasterMock(c.io.inp)
    val wgt_mock = new TensorMasterMock(c.io.wgt)
    val acc_mock = new TensorMasterMock(c.io.acc)

    def logical_step(sram_valid: BigInt, uop_valid: BigInt) {
      step(1)
      uop_mock.logical_step(uop_valid)
      inp_mock.logical_step(sram_valid)
      wgt_mock.logical_step(sram_valid)
      acc_mock.logical_step(sram_valid)
    }
  }

  val mocks = new Mocks
  poke(c.io.start, 0)

  step(1)

  expect(c.io.state, c.sIdle)

  poke(c.io.start, 1)
  mocks.logical_step(0, 1)
  expect(c.io.state, c.sReadUop)

  expect(c.io.out.wr(0).valid, 0)
  expect(c.io.acc.wr(0).valid, 0)

  poke(c.io.start, 0)

  mocks.logical_step(0, 0)
  expect(c.io.state, c.sComputeIdx)
  expect(c.io.out.wr(0).valid, 0)
  expect(c.io.acc.wr(0).valid, 0)

  mocks.logical_step(1, 0)
  expect(c.io.state, c.sReadTensor)
  expect(c.io.out.wr(0).valid, 0)
  expect(c.io.acc.wr(0).valid, 0)

  mocks.logical_step(0, 0)
  expect(c.io.state, c.sExe)
  expect(c.io.out.wr(0).valid, 0)
  expect(c.io.acc.wr(0).valid, 0)
  expect(c.io.done, 0)

  mocks.logical_step(0, 0)
  expect(c.io.state, c.sWait)
  expect(c.io.inflight, 1)

  expect(c.io.out.wr(0).valid, 0)
  expect(c.io.acc.wr(0).valid, 0)

  mocks.logical_step(0, 0)
  expect(c.io.state, c.sWait)
  expect(c.io.inflight, 1)

  expect(c.io.out.wr(0).valid, 1)
  expect(c.io.acc.wr(0).valid, 1)

  mocks.logical_step(0, 0)
  expect(c.io.state, c.sWait)
  expect(c.io.inflight, 0)

  expect(c.io.out.wr(0).valid, 0)
  expect(c.io.acc.wr(0).valid, 0)

  mocks.logical_step(0, 0)
  expect(c.io.state, c.sIdle)
  expect(c.io.inflight, 0)

  expect(c.io.out.wr(0).valid, 0)
  expect(c.io.acc.wr(0).valid, 0)

}

class TensorGemmTest extends GenericTest("TensorGemm", (p:Parameters) => new TensorGemmSimple()(p),
  (c:TensorGemmSimple) => new TensorGemmTester(c))

class TensorGemmIdxTester(c: TensorGemmSimple) extends PeekPokeTester(c) {

  poke(c.io.start, 0)

  val uop_begin = 0
  val uop_end = 2
  assert(uop_begin < uop_end)
  val lp_0 = 2
  val lp_1 = 3
  val acc_0 = 1*lp_1
  val inp_0 = 2*lp_1
  val wgt_0 = 4*lp_1
  val acc_1 = 1
  val inp_1 = 2
  val wgt_1 = 4
  val u0 = BigInt("000", 16)
  val u1 = BigInt("100", 16)
  val u2 = BigInt("200", 16)

  poke(c.io.dec.reset, 0)
  poke(c.io.dec.uop_begin, uop_begin)
  poke(c.io.dec.uop_end, uop_end)
  poke(c.io.dec.lp_0, lp_0)
  poke(c.io.dec.lp_1, lp_1)
  poke(c.io.dec.acc_0, acc_0)
  poke(c.io.dec.acc_1, acc_1)
  poke(c.io.dec.inp_0, inp_0)
  poke(c.io.dec.inp_1, inp_1)
  poke(c.io.dec.wgt_0, wgt_0)
  poke(c.io.dec.wgt_1, wgt_1)
  // Don't need empty_0,{push,pop}_{next,prev},op

  poke(c.io.uop.data.bits.u0, u0)
  poke(c.io.uop.data.bits.u1, u1)
  poke(c.io.uop.data.bits.u2, u2)

  val inp = IndexedSeq.fill(c.io.inp.rd(0).data.bits(0).size){BigInt(1)}
  for {lhs <- c.io.inp.rd(0).data.bits} {
    poke(lhs, inp.reverse)
  }

  val wgt = IndexedSeq.fill(c.io.wgt.rd(0).data.bits(0).size){BigInt(1)}
  for {lhs <- c.io.wgt.rd(0).data.bits} {
    poke(lhs, wgt.reverse)
  }

  val acc = IndexedSeq.fill(c.io.acc.rd(0).data.bits(0).size){BigInt(1)}
  for {lhs <- c.io.acc.rd(0).data.bits} {
    poke(lhs, acc.reverse)
  }

  class TensorMasterMock(tm: TensorMaster) {
    poke(tm.rd(0).data.valid, 0)
    var valid = peek(tm.rd(0).idx.valid)
    def logical_step(v: BigInt) {
      poke(tm.rd(0).data.valid, valid)
      valid = peek(tm.rd(0).idx.valid)
      expect(tm.rd(0).idx.valid, v)
    }
  }

  class UopMasterMock(um: UopMaster) {
    poke(um.data.valid, 0)
    var valid = peek(um.idx.valid)
    def logical_step(v: BigInt) {
      poke(um.data.valid, valid)
      valid = peek(um.idx.valid)
      expect(um.idx.valid, v)
    }
  }

  class Mocks {
    val uop_mock = new UopMasterMock(c.io.uop)
    val inp_mock = new TensorMasterMock(c.io.inp)
    val wgt_mock = new TensorMasterMock(c.io.wgt)
    val acc_mock = new TensorMasterMock(c.io.acc)

    val uop_indices = new scala.collection.mutable.Queue[BigInt]
    val acc_indices = new scala.collection.mutable.Queue[BigInt]
    val inp_indices = new scala.collection.mutable.Queue[BigInt]
    val wgt_indices = new scala.collection.mutable.Queue[BigInt]
    val accout_indices = new scala.collection.mutable.Queue[BigInt]
    val out_indices = new scala.collection.mutable.Queue[BigInt]

    def logical_step(sram_valid: BigInt, uop_valid: BigInt) {
      step(1)
      uop_mock.logical_step(uop_valid)
      inp_mock.logical_step(sram_valid)
      wgt_mock.logical_step(sram_valid)
      acc_mock.logical_step(sram_valid)
      if (peek(c.io.uop.idx.valid) == 1) {
        expect(c.io.uop.idx.bits, uop_indices.dequeue())
      }
      if (peek(c.io.acc.rd(0).idx.valid) == 1) {
        expect(c.io.acc.rd(0).idx.bits, acc_indices.dequeue())
      }
      if (peek(c.io.inp.rd(0).idx.valid) == 1) {
        expect(c.io.inp.rd(0).idx.bits, inp_indices.dequeue())
      }
      if (peek(c.io.wgt.rd(0).idx.valid) == 1) {
        expect(c.io.wgt.rd(0).idx.bits, wgt_indices.dequeue())
      }
      if (peek(c.io.acc.wr(0).valid) == 1) {
        expect(c.io.acc.wr(0).bits.idx, accout_indices.dequeue())
      }
      if (peek(c.io.out.wr(0).valid) == 1) {
        expect(c.io.out.wr(0).bits.idx, out_indices.dequeue())
      }
    }

    def test_if_done() {
      assert(uop_indices.isEmpty)
      assert(acc_indices.isEmpty)
      assert(inp_indices.isEmpty)
      assert(wgt_indices.isEmpty)
    }
  }

  val mocks = new Mocks
  for {
    cnt_o <- 0 until lp_0
    cnt_i <- 0 until lp_1
    uop_idx <- uop_begin until uop_end
  } {
    mocks.uop_indices.enqueue(uop_idx)
    mocks.acc_indices.enqueue(u0 + acc_0*cnt_o + acc_1*cnt_i)
    mocks.inp_indices.enqueue(u1 + inp_0*cnt_o + inp_1*cnt_i)
    mocks.wgt_indices.enqueue(u2 + wgt_0*cnt_o + wgt_1*cnt_i)
    mocks.accout_indices.enqueue(u0 + acc_0*cnt_o + acc_1*cnt_i)
    mocks.out_indices.enqueue(u0 + acc_0*cnt_o + acc_1*cnt_i)
  }

  poke(c.io.start, 0)
  step(1)
  expect(c.io.state, c.sIdle)

  poke(c.io.start, 1)

  for {q <- 0 until (uop_end-uop_begin)*lp_0*lp_1} {
    mocks.logical_step(0, 1)
    expect(c.io.out.wr(0).valid, 0)
    expect(c.io.acc.wr(0).valid, 0)

    poke(c.io.start, 0)

    mocks.logical_step(0, 0)
    expect(c.io.out.wr(0).valid, if (q > 0) 1 else 0)
    expect(c.io.acc.wr(0).valid, if (q > 0) 1 else 0)

    mocks.logical_step(1, 0)
    expect(c.io.out.wr(0).valid, 0)
    expect(c.io.acc.wr(0).valid, 0)

    mocks.logical_step(0, 0)
    expect(c.io.out.wr(0).valid, 0)
    expect(c.io.acc.wr(0).valid, 0)
    expect(c.io.done, 0)
  }

  mocks.logical_step(0, 0)
  expect(c.io.inflight, 1)

  expect(c.io.out.wr(0).valid, 0)
  expect(c.io.acc.wr(0).valid, 0)

  mocks.logical_step(0, 0)
  expect(c.io.inflight, 1)

  expect(c.io.out.wr(0).valid, 1)
  expect(c.io.acc.wr(0).valid, 1)

  mocks.logical_step(0, 0)
  expect(c.io.inflight, 0)

  expect(c.io.out.wr(0).valid, 0)
  expect(c.io.acc.wr(0).valid, 0)

  mocks.logical_step(0, 0)
  expect(c.io.inflight, 0)

  expect(c.io.out.wr(0).valid, 0)
  expect(c.io.acc.wr(0).valid, 0)

  mocks.test_if_done()
}

class TensorGemmIdxTest extends GenericTest("TensorGemmIdx", (p:Parameters) => new TensorGemmSimple()(p),
  (c:TensorGemmSimple) => new TensorGemmIdxTester(c))

class TensorGemmIndexGeneratorTester(c: TensorGemmIndexGenerator) extends PeekPokeTester(c) {
  val uop_begin = 0
  val uop_end = 2
  assert(uop_begin < uop_end)
  val lp_0 = 2
  val lp_1 = 3
  val acc_0 = 1*lp_1
  val inp_0 = 2*lp_1
  val wgt_0 = 4*lp_1
  val acc_1 = 1
  val inp_1 = 2
  val wgt_1 = 4

  poke(c.io.dec.reset, 0)
  poke(c.io.dec.uop_begin, uop_begin)
  poke(c.io.dec.uop_end, uop_end)
  poke(c.io.dec.lp_0, lp_0)
  poke(c.io.dec.lp_1, lp_1)
  poke(c.io.dec.acc_0, acc_0)
  poke(c.io.dec.acc_1, acc_1)
  poke(c.io.dec.inp_0, inp_0)
  poke(c.io.dec.inp_1, inp_1)
  poke(c.io.dec.wgt_0, wgt_0)
  poke(c.io.dec.wgt_1, wgt_1)
  // Don't need empty_0,{push,pop}_{next,prev},op

  class Mocks {
    val uop_indices = new scala.collection.mutable.Queue[BigInt]
    val acc_indices = new scala.collection.mutable.Queue[BigInt]
    val inp_indices = new scala.collection.mutable.Queue[BigInt]
    val wgt_indices = new scala.collection.mutable.Queue[BigInt]

    def logical_step() {
      step(1)
      if (peek(c.io.valid) == 1) {
        expect(c.io.uop_idx, uop_indices.dequeue())
        expect(c.io.acc_i, acc_indices.dequeue())
        expect(c.io.inp_i, inp_indices.dequeue())
        expect(c.io.wgt_i, wgt_indices.dequeue())
      }
    }

    def test_if_done() {
      println(s"uop_indices remaining: ${uop_indices.size}")
      println(s"acc_indices remaining: ${acc_indices.size}")
      println(s"inp_indices remaining: ${inp_indices.size}")
      println(s"wgt_indices remaining: ${wgt_indices.size}")
      assert(uop_indices.isEmpty)
      assert(acc_indices.isEmpty)
      assert(inp_indices.isEmpty)
      assert(wgt_indices.isEmpty)
    }
  }

  val mocks = new Mocks
  for {
    cnt_o <- 0 until lp_0
    cnt_i <- 0 until lp_1
    uop_idx <- uop_begin until uop_end
  } {
    mocks.uop_indices.enqueue(uop_idx)
    mocks.acc_indices.enqueue(acc_0*cnt_o + acc_1*cnt_i)
    mocks.inp_indices.enqueue(inp_0*cnt_o + inp_1*cnt_i)
    mocks.wgt_indices.enqueue(wgt_0*cnt_o + wgt_1*cnt_i)
  }

  poke(c.io.start, 1)
  mocks.logical_step()
  poke(c.io.start, 0)

  val end = (uop_end-uop_begin)*lp_0*lp_1
  var count = 0
  while(peek(c.io.last) == 0 && count < 10*end + 100) {
    mocks.logical_step()
    count += 1
  }
  mocks.test_if_done()
}

class TensorGemmIndexGeneratorTest extends GenericTest("TensorGemmIndexGenerator",
  (p:Parameters) => new TensorGemmIndexGenerator()(p),
  (c:TensorGemmIndexGenerator) => new TensorGemmIndexGeneratorTester(c))

class TensorGemmPipelinedTester(c: TensorGemmPipelinedSplit) extends PeekPokeTester(c) {
  poke(c.io.start, 0)

  val uop_begin = 0
  val uop_end = 2
  assert(uop_begin < uop_end)
  val lp_0 = 2
  val lp_1 = 3
  val acc_0 = 1*lp_1
  val inp_0 = 2*lp_1
  val wgt_0 = 4*lp_1
  val acc_1 = 1
  val inp_1 = 2
  val wgt_1 = 4
  val u0 = BigInt("000", 16)
  val u1 = BigInt("100", 16)
  val u2 = BigInt("200", 16)

  poke(c.io.dec.reset, 0)
  poke(c.io.dec.uop_begin, uop_begin)
  poke(c.io.dec.uop_end, uop_end)
  poke(c.io.dec.lp_0, lp_0)
  poke(c.io.dec.lp_1, lp_1)
  poke(c.io.dec.acc_0, acc_0)
  poke(c.io.dec.acc_1, acc_1)
  poke(c.io.dec.inp_0, inp_0)
  poke(c.io.dec.inp_1, inp_1)
  poke(c.io.dec.wgt_0, wgt_0)
  poke(c.io.dec.wgt_1, wgt_1)
  // Don't need empty_0,{push,pop}_{next,prev},op

  poke(c.io.uop.data.bits.u0, u0)
  poke(c.io.uop.data.bits.u1, u1)
  poke(c.io.uop.data.bits.u2, u2)

  val inp = IndexedSeq.fill(c.io.inp.rd(0).data.bits(0).size){BigInt(1)}
  for {lhs <- c.io.inp.rd(0).data.bits} {
    poke(lhs, inp.reverse)
  }

  val wgt = IndexedSeq.fill(c.io.wgt.rd(0).data.bits(0).size){BigInt(1)}
  for {lhs <- c.io.wgt.rd(0).data.bits} {
    poke(lhs, wgt.reverse)
  }

  val acc = IndexedSeq.fill(c.io.acc.rd(0).data.bits(0).size){BigInt(1)}
  for {lhs <- c.io.acc.rd(0).data.bits} {
    poke(lhs, acc.reverse)
  }

  class TensorMasterMock(tm: TensorMaster) {
    poke(tm.rd(0).data.valid, 0)
    var valid = peek(tm.rd(0).idx.valid)
    def logical_step(v: Option[BigInt]) {
      poke(tm.rd(0).data.valid, valid)
      valid = peek(tm.rd(0).idx.valid)
      for {x <- v} expect(tm.rd(0).idx.valid, x)
    }
  }

  class UopMasterMock(um: UopMaster) {
    poke(um.data.valid, 0)
    var valid = peek(um.idx.valid)
    def logical_step(v: Option[BigInt]) {
      poke(um.data.valid, valid)
      valid = peek(um.idx.valid)
      for {x <- v} expect(um.idx.valid, x)
    }
  }

  class Mocks {
    val uop_mock = new UopMasterMock(c.io.uop)
    val inp_mock = new TensorMasterMock(c.io.inp)
    val wgt_mock = new TensorMasterMock(c.io.wgt)
    val acc_mock = new TensorMasterMock(c.io.acc)

    val uop_indices = new scala.collection.mutable.Queue[BigInt]
    val acc_indices = new scala.collection.mutable.Queue[BigInt]
    val inp_indices = new scala.collection.mutable.Queue[BigInt]
    val wgt_indices = new scala.collection.mutable.Queue[BigInt]
    val accout_indices = new scala.collection.mutable.Queue[BigInt]
    val out_indices = new scala.collection.mutable.Queue[BigInt]

    def logical_step() {
      step(1)
      uop_mock.logical_step(None)
      inp_mock.logical_step(None)
      wgt_mock.logical_step(None)
      acc_mock.logical_step(None)
      if (peek(c.io.uop.idx.valid) == 1) {
        expect(c.io.uop.idx.bits, uop_indices.dequeue())
      }
      if (peek(c.io.acc.rd(0).idx.valid) == 1) {
        expect(c.io.acc.rd(0).idx.bits, acc_indices.dequeue())
      }
      if (peek(c.io.inp.rd(0).idx.valid) == 1) {
        expect(c.io.inp.rd(0).idx.bits, inp_indices.dequeue())
      }
      if (peek(c.io.wgt.rd(0).idx.valid) == 1) {
        expect(c.io.wgt.rd(0).idx.bits, wgt_indices.dequeue())
      }
      if (peek(c.io.acc.wr(0).valid) == 1) {
        expect(c.io.acc.wr(0).bits.idx, accout_indices.dequeue())
      }
      if (peek(c.io.out.wr(0).valid) == 1) {
        expect(c.io.out.wr(0).bits.idx, out_indices.dequeue())
      }
    }

    def test_if_done() {
      println(s"uop_indices remaining: ${uop_indices.size}")
      println(s"acc_indices remaining: ${acc_indices.size}")
      println(s"inp_indices remaining: ${inp_indices.size}")
      println(s"wgt_indices remaining: ${wgt_indices.size}")
      println(s"accout_indices remaining: ${accout_indices.size}")
      println(s"out_indices remaining: ${out_indices.size}")
    }
  }

  val mocks = new Mocks
  for {
    cnt_o <- 0 until lp_0
    cnt_i <- 0 until lp_1
    uop_idx <- uop_begin until uop_end
  } {
    mocks.uop_indices.enqueue(uop_idx)
    mocks.acc_indices.enqueue(u0 + acc_0*cnt_o + acc_1*cnt_i)
    mocks.inp_indices.enqueue(u1 + inp_0*cnt_o + inp_1*cnt_i)
    mocks.wgt_indices.enqueue(u2 + wgt_0*cnt_o + wgt_1*cnt_i)
    mocks.accout_indices.enqueue(u0 + acc_0*cnt_o + acc_1*cnt_i)
    mocks.out_indices.enqueue(u0 + acc_0*cnt_o + acc_1*cnt_i)
  }

  poke(c.io.start, 0)
  step(1)
  expect(c.io.state, c.sIdle)
  poke(c.io.start, 1)

  var count = 0
  val end = (uop_end-uop_begin)*lp_0*lp_1

  while (peek(c.io.done) == 0 && count < 10*end + 100) {
    mocks.logical_step()
    poke(c.io.start, 0)
  }

  expect(c.io.done, 1)
  mocks.test_if_done()
}

class TensorGemmPipelinedTest extends GenericTest("TensorGemmPipelined",
  (p:Parameters) => new TensorGemmPipelinedSplit()(p),
  (c:TensorGemmPipelinedSplit) => new TensorGemmPipelinedTester(c))

class TensorGemmResetTester(c: TensorGemm) extends PeekPokeTester(c) {
  poke(c.io.start, 0)

  val uop_begin = 0
  val uop_end = 2
  assert(uop_begin < uop_end)
  val lp_0 = 2
  val lp_1 = 3
  val acc_0 = 1*lp_1
  val inp_0 = 2*lp_1
  val wgt_0 = 4*lp_1
  val acc_1 = 1
  val inp_1 = 2
  val wgt_1 = 4
  val u0 = BigInt("000", 16)
  val u1 = BigInt("100", 16)
  val u2 = BigInt("200", 16)
  val dec_reset = 1

  poke(c.io.dec.reset, dec_reset)
  poke(c.io.dec.uop_begin, uop_begin)
  poke(c.io.dec.uop_end, uop_end)
  poke(c.io.dec.lp_0, lp_0)
  poke(c.io.dec.lp_1, lp_1)
  poke(c.io.dec.acc_0, acc_0)
  poke(c.io.dec.acc_1, acc_1)
  poke(c.io.dec.inp_0, inp_0)
  poke(c.io.dec.inp_1, inp_1)
  poke(c.io.dec.wgt_0, wgt_0)
  poke(c.io.dec.wgt_1, wgt_1)
  // Don't need empty_0,{push,pop}_{next,prev},op

  poke(c.io.uop.data.bits.u0, u0)
  poke(c.io.uop.data.bits.u1, u1)
  poke(c.io.uop.data.bits.u2, u2)

  val inp = IndexedSeq.fill(c.io.inp.rd(0).data.bits(0).size){BigInt(1)}
  for {lhs <- c.io.inp.rd(0).data.bits} {
    poke(lhs, inp.reverse)
  }

  val wgt = IndexedSeq.fill(c.io.wgt.rd(0).data.bits(0).size){BigInt(1)}
  for {lhs <- c.io.wgt.rd(0).data.bits} {
    poke(lhs, wgt.reverse)
  }

  val acc = IndexedSeq.fill(c.io.acc.rd(0).data.bits(0).size){BigInt(1)}
  for {lhs <- c.io.acc.rd(0).data.bits} {
    poke(lhs, acc.reverse)
  }

  class TensorMasterMock(tm: TensorMaster) {
    poke(tm.rd(0).data.valid, 0)
    var valid = peek(tm.rd(0).idx.valid)
    def logical_step(v: Option[BigInt]) {
      poke(tm.rd(0).data.valid, valid)
      valid = peek(tm.rd(0).idx.valid)
      for {x <- v} expect(tm.rd(0).idx.valid, x)
    }
  }

  class UopMasterMock(um: UopMaster) {
    poke(um.data.valid, 0)
    var valid = peek(um.idx.valid)
    def logical_step(v: Option[BigInt]) {
      poke(um.data.valid, valid)
      valid = peek(um.idx.valid)
      for {x <- v} expect(um.idx.valid, x)
    }
  }

  class Mocks {
    val uop_mock = new UopMasterMock(c.io.uop)
    val inp_mock = new TensorMasterMock(c.io.inp)
    val wgt_mock = new TensorMasterMock(c.io.wgt)
    val acc_mock = new TensorMasterMock(c.io.acc)

    val uop_indices = new scala.collection.mutable.Queue[BigInt]
    val acc_indices = new scala.collection.mutable.Queue[BigInt]
    val inp_indices = new scala.collection.mutable.Queue[BigInt]
    val wgt_indices = new scala.collection.mutable.Queue[BigInt]
    val accout_indices = new scala.collection.mutable.Queue[BigInt]
    val out_indices = new scala.collection.mutable.Queue[BigInt]

    def logical_step(sram_valid: BigInt, uop_valid: BigInt) {
      step(1)
      uop_mock.logical_step(None)
      inp_mock.logical_step(None)
      wgt_mock.logical_step(None)
      acc_mock.logical_step(None)
      if (peek(c.io.uop.idx.valid) == 1) {
        expect(c.io.uop.idx.bits, uop_indices.dequeue())
      }
      if (peek(c.io.acc.rd(0).idx.valid) == 1) {
        expect(c.io.acc.rd(0).idx.bits, acc_indices.dequeue())
      }
      if (peek(c.io.inp.rd(0).idx.valid) == 1) {
        expect(c.io.inp.rd(0).idx.bits, inp_indices.dequeue())
      }
      if (peek(c.io.wgt.rd(0).idx.valid) == 1) {
        expect(c.io.wgt.rd(0).idx.bits, wgt_indices.dequeue())
      }
      if (peek(c.io.acc.wr(0).valid) == 1) {
        expect(c.io.acc.wr(0).bits.idx, accout_indices.dequeue())
      }
      if (peek(c.io.out.wr(0).valid) == 1) {
        expect(c.io.out.wr(0).bits.idx, out_indices.dequeue())
      }
    }

    def test_if_done() {
      assert(uop_indices.isEmpty)
      assert(acc_indices.isEmpty)
      assert(inp_indices.isEmpty)
      assert(wgt_indices.isEmpty)
      assert(accout_indices.isEmpty)
      assert(out_indices.isEmpty)
    }
  }

  val mocks = new Mocks
  for {
    cnt_o <- 0 until lp_0
    cnt_i <- 0 until lp_1
    uop_idx <- uop_begin until uop_end
  } {
    mocks.uop_indices.enqueue(uop_idx)
    mocks.acc_indices.enqueue(u0 + acc_0*cnt_o + acc_1*cnt_i)
    mocks.inp_indices.enqueue(u1 + inp_0*cnt_o + inp_1*cnt_i)
    mocks.wgt_indices.enqueue(u2 + wgt_0*cnt_o + wgt_1*cnt_i)
    mocks.accout_indices.enqueue(u0 + acc_0*cnt_o + acc_1*cnt_i)

    if (dec_reset == 0) {
      mocks.out_indices.enqueue(u0 + acc_0*cnt_o + acc_1*cnt_i)
    }
  }

  poke(c.io.start, 0)
  step(1)
  expect(c.io.state, c.sIdle)
  poke(c.io.start, 1)

  while(peek(c.io.done) == 0) {
    mocks.logical_step(0, 0)
    poke(c.io.start, 0)
  }

  mocks.test_if_done()
}

class TensorGemmResetTest extends GenericTest("TensorGemmReset", (p:Parameters) => new TensorGemm()(p),
  (c:TensorGemm) => new TensorGemmResetTester(c))