#include <TDmaMult.hpp>

Inheritance diagram for TDmaMult:

Public Member Functions
DmaState	GetDmaState ()

SimulationTime	Run ()

void	Reset ()

	TDmaMult (std::string name, Signal< uint8_t > stall, Signal< uint8_t > dma_start, Signal< uint32_t > burst_size, Signal< uint32_t > nn_size, Signal< uint32_t > out_size, uint32_t base_mac_out_addr, Memory main_mem)
	ctor More...

	~TDmaMult ()
	dtor More...

Private Member Functions
void	ReadData ()
	Internal processes – 3 stage pipeline. More...

void	DoMult ()

void	DoAcc ()

Private Attributes
Memory *	_mem0

uint32_t	_memW [SIMD_SIZE]

uint32_t	_memI [SIMD_SIZE]

uint32_t	_base_mac_out_addr

DmaState	_dma_state

Signal< uint8_t > *	_sig_stall

Signal< uint8_t > *	_sig_dma_prog

Signal< uint32_t > *	_sig_burst_size

Signal< uint32_t > *	_sig_nn_size

Signal< uint32_t > *	_sig_out_size

float	_op1 [SIMD_SIZE]

float	_op2 [SIMD_SIZE]

float	_reg_mul [SIMD_SIZE]

float	_reg_mac [SIMD_SIZE]

uint8_t	_mul_loaded
	pipeline signals. More...

uint8_t	_mul_ready

uint32_t	_burst_size

uint32_t	nn_size

uint32_t	out_size

uint32_t	_remaining
	count number of data to be read. More...

uint32_t	_mem_idx
	memory idx used to access both the input and weight memories. More...

Detailed Description

Author: Alexandre Amory, based on Anderson's TDMANetif

Date: 01/04/20

Definition at line 69 of file TDmaMult.hpp.

Constructor & Destructor Documentation

§ TDmaMult()

TDmaMult::TDmaMult	(	std::string	name,
		Signal< uint8_t > *	stall,
		Signal< uint8_t > *	dma_start,
		Signal< uint32_t > *	burst_size,
		Signal< uint32_t > *	nn_size,
		Signal< uint32_t > *	out_size,
		uint32_t	base_mac_out_addr,
		Memory *	main_mem
	)

ctor

This file is part of project URSA.

Parameters

name	name of the module.
stall	signal to stall the processor while the DMA is going on.
burst_size	MMIO with the total number of multiplications.
nn_size	(not used) number of NN memory banks for a single MAC.
out_size	(not used) number of expected output data.
base_mac_out_addr	base address to the array with the output of the MACs.
mac	pointer to the MAC module.

More information on the project can be found at URSA's repository at GitHub

http://https://github.com/andersondomingues/ursa

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

Definition at line 34 of file TDmaMult.cpp.

                                                                               : TimedModel(name) {
     
     int i;
 
     // control signal sent to the proc
     _sig_stall = stall;
     _sig_dma_prog = dma_start;
 
     // data signals sent by the proc
     _sig_burst_size = burst_size;
     _sig_nn_size = nn_size;   // TODO not used
     _sig_out_size = out_size; // TODO not used
     _base_mac_out_addr = base_mac_out_addr;
 
     // set the base mamory address to each channel
     _memW[0] = MEMW_BASE;
     _memI[0] = MEMI_BASE;
     for ( i = 1; i < SIMD_SIZE; i++)
     {
         _memW[i] = _memW[i-1] + NN_MEM_SIZE_PER_CHANNEL;
         _memI[i] = _memI[i-1] + NN_MEM_SIZE_PER_CHANNEL;
     }
     _mem0 = main_mem;
     
     // internal control 'registers' between the pipeline stages
     _mul_loaded  = 0;
     _mul_ready   = 0;
 
     printf("NN CONFIGURATION:\n\n");
     printf("  TOTAL_NN_MEM_SIZE = 0x%x\n",TOTAL_NN_MEM_SIZE);
     printf("  SIMD_SIZE = %d\n",SIMD_SIZE);
     printf("  NN_MEM_SIZE_PER_CHANNEL = 0x%x\n",NN_MEM_SIZE_PER_CHANNEL);
     printf("  MEMW_BASE = 0x%x\n",MEMW_BASE);
     printf("  MEMI_BASE = 0x%x\n",MEMI_BASE);
     printf("  DMA_MAC_OUT_ARRAY = 0x%x\n\n",base_mac_out_addr);
 
     this->Reset();
 }

§ ~TDmaMult()

TDmaMult::~TDmaMult ( )

dtor

Definition at line 76 of file TDmaMult.cpp.

76 {

77 }

Member Function Documentation

§ DoAcc()

void TDmaMult::DoAcc ( )

private

Definition at line 107 of file TDmaMult.cpp.

                     {
     int i;
     switch(_dma_state){ 
         case DmaState::WAIT_CONFIG_STALL:{
             for (i=0;i<SIMD_SIZE;i++){
                 _reg_mac[i] = 0;
             }
             }break;
         case DmaState::COPY_FROM_MEM:{
             if (_mul_ready == 0x1){
                 for (i=0;i<SIMD_SIZE;i++){
                     _reg_mac[i] += _reg_mul[i];
                 }
             } 
             }break;
         case DmaState::COPY_TO_CPU:{
             float *ptr = (float *)_mem0->GetMap(_base_mac_out_addr);
             for (i=0;i<SIMD_SIZE;i++){
                 //printf ("MAC[%d]: %f - 0x%p\n", i, _reg_mac[i], &(_reg_mac[i]));
                 *ptr = _reg_mac[i];  // send the final result back to the processor
                 ptr++;
             }
             }break;
         case DmaState::FLUSH:
             break;
     }
 }

§ DoMult()

void TDmaMult::DoMult ( )

private

Definition at line 137 of file TDmaMult.cpp.

                      {
     int i;
     if (_dma_state == DmaState::WAIT_CONFIG_STALL){
         for (i=0;i<SIMD_SIZE;i++){
             _reg_mul[i] = 0; // restart register 
         }       
         _mul_ready = 0;
     }
     else {
         if (_mul_loaded == 0x1){
             for (i=0;i<SIMD_SIZE;i++){
                 _reg_mul[i] = _op1[i] * _op2[i]; // mult
             }               
             _mul_ready = 1;
         }else{
             _mul_ready = 0;
         }
     }
 }

§ GetDmaState()

DmaState TDmaMult::GetDmaState ( )

Definition at line 92 of file TDmaMult.cpp.

92 {return _dma_state;}

TDmaMult::_dma_state

DmaState _dma_state

Definition: TDmaMult.hpp:83

§ ReadData()

void TDmaMult::ReadData ( )

private

Internal processes – 3 stage pipeline.

Definition at line 158 of file TDmaMult.cpp.

                        {
     int i;
     //send state machine
     switch(_dma_state){
         //wait the cpu to configure the ni
         case DmaState::WAIT_CONFIG_STALL:{
             if(_sig_dma_prog->Read() == 0x1){
                 _sig_stall->Write(0x1);        //raise stall
                 _mul_loaded = 0;   // raised when the mul can be executed
                 // reading data sent from the proc to the DMA
                 _burst_size = _sig_burst_size->Read();
                 if (_burst_size > NN_MEM_SIZE_PER_CHANNEL){
                     stringstream s;
                     s << this->GetName() << ": burst size exedded the NN memory capacity.";
                     throw std::runtime_error(s.str());
                 } 
 //              _w_mem_idx = _sig_nn_size->Read();
 //              _i_mem_idx = _sig_out_size->Read();
                 // init counters used for burst mode operation
                 _mem_idx = 0;
                 _remaining = _burst_size;
                 _dma_state = DmaState::COPY_FROM_MEM; //change states
             }
             
         } break;
 
         //copy data from the NN memory to the internal MAC registers
         case DmaState::COPY_FROM_MEM:{
             
             if(_remaining > 0){
                 int8_t * w_ptr, * i_ptr;
 
                 for (i=0;i<SIMD_SIZE;i++){
                     w_ptr = _mem0->GetMap(_memW[i]+_mem_idx);
                     _op1[i] = *(float*)w_ptr;
                     i_ptr = _mem0->GetMap(_memI[i]+_mem_idx);
                     _op2[i]  = *(float*)i_ptr;
                     //if ( _op1[i] != 0.0f)
                     //  printf ("OPs[%d %d]: %f %f\n", _mem_idx, i, _op1[i], _op2[i]);
                 }
                 //signal to the next pipiline stage
                 _mul_loaded = 1; 
                 // updating counters used for burst mode operation
                 _remaining--; //one less packet to send
                 _mem_idx +=4;
             }else{
                 _mul_loaded = 0; 
                 _dma_state = DmaState::COPY_TO_CPU;
             }
         } break;    
 
         case DmaState::COPY_TO_CPU:{
             // result is written back to the output MMIO register
             _dma_state = DmaState::FLUSH;
             }break;
 
         // just waits few clock cycles. currently, only one cycle
         case DmaState::FLUSH:
             _dma_state = DmaState::WAIT_CONFIG_STALL;
             // TODO multiple drivers to signal _sig_dma_prog !!! implement a handshare protocol between proc and dma 
             _sig_dma_prog->Write(0x0);     //lower the start signal . 
             _sig_stall->Write(0x0);        //lowering stall and giving the control back to the processor
             break;
     }
 }

§ Reset()

void TDmaMult::Reset ( )

Definition at line 79 of file TDmaMult.cpp.

                     {
     int i;
     // all relevant data go to their initial value at this state
     _dma_state = DmaState::WAIT_CONFIG_STALL;
 
     // get the pointer to the base memory position where the MACs store their final values 
     float *ptr = (float *)_mem0->GetMap(_base_mac_out_addr);
     for (i=0;i<SIMD_SIZE;i++){
         *ptr = 0;
         ptr++;
     }
 }

§ Run()

SimulationTime TDmaMult::Run ( )

Definition at line 94 of file TDmaMult.cpp.

                             {
     // TODO fazer loop p realizar o mac de todo o vetor
     //3 stage pipeline
     this->DoAcc();     // 3rd stage, accumulator
     this->DoMult();    // 2nd stage, does mult
     this->ReadData();  // 1st stage, read data from the memory
 
     return 1; //takes only 1 cycle to change both states
 }

Member Data Documentation

§ _base_mac_out_addr

uint32_t TDmaMult::_base_mac_out_addr

private

Definition at line 81 of file TDmaMult.hpp.

§ _burst_size

uint32_t TDmaMult::_burst_size

private

Definition at line 116 of file TDmaMult.hpp.

§ _dma_state

DmaState TDmaMult::_dma_state

private

Definition at line 83 of file TDmaMult.hpp.

§ _mem0

Memory* TDmaMult::_mem0

private

Definition at line 72 of file TDmaMult.hpp.

§ _mem_idx

uint32_t TDmaMult::_mem_idx

private

memory idx used to access both the input and weight memories.

Definition at line 122 of file TDmaMult.hpp.

§ _memI

uint32_t TDmaMult::_memI[SIMD_SIZE]

private

Definition at line 78 of file TDmaMult.hpp.

§ _memW

uint32_t TDmaMult::_memW[SIMD_SIZE]

private

Definition at line 75 of file TDmaMult.hpp.

§ _mul_loaded

uint8_t TDmaMult::_mul_loaded

private

pipeline signals.

Definition at line 112 of file TDmaMult.hpp.

§ _mul_ready

uint8_t TDmaMult::_mul_ready

private

Definition at line 113 of file TDmaMult.hpp.

§ _op1

float TDmaMult::_op1[SIMD_SIZE]

private

Definition at line 104 of file TDmaMult.hpp.

§ _op2

float TDmaMult::_op2[SIMD_SIZE]

private

Definition at line 104 of file TDmaMult.hpp.

§ _reg_mac

float TDmaMult::_reg_mac[SIMD_SIZE]

private

Definition at line 109 of file TDmaMult.hpp.

§ _reg_mul

float TDmaMult::_reg_mul[SIMD_SIZE]

private

Definition at line 107 of file TDmaMult.hpp.

§ _remaining

uint32_t TDmaMult::_remaining

private

count number of data to be read.

Definition at line 120 of file TDmaMult.hpp.

§ _sig_burst_size

Signal<uint32_t>* TDmaMult::_sig_burst_size

private

Definition at line 93 of file TDmaMult.hpp.

§ _sig_dma_prog

Signal<uint8_t>* TDmaMult::_sig_dma_prog

private

Definition at line 89 of file TDmaMult.hpp.

§ _sig_nn_size

Signal<uint32_t>* TDmaMult::_sig_nn_size

private

Definition at line 97 of file TDmaMult.hpp.

§ _sig_out_size

Signal<uint32_t>* TDmaMult::_sig_out_size

private

Definition at line 99 of file TDmaMult.hpp.

§ _sig_stall

Signal<uint8_t>* TDmaMult::_sig_stall

private

Definition at line 87 of file TDmaMult.hpp.

§ nn_size

uint32_t TDmaMult::nn_size

private

Definition at line 117 of file TDmaMult.hpp.

§ out_size

uint32_t TDmaMult::out_size

private

Definition at line 118 of file TDmaMult.hpp.

The documentation for this class was generated from the following files:

platforms/single-core-nn/include/TDmaMult.hpp
platforms/single-core-nn/src/TDmaMult.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

§ TDmaMult()

§ ~TDmaMult()

Member Function Documentation

§ DoAcc()

§ DoMult()

§ GetDmaState()

§ ReadData()

§ Reset()

§ Run()

Member Data Documentation

§ _base_mac_out_addr

§ _burst_size

§ _dma_state

§ _mem0

§ _mem_idx

§ _memI

§ _memW

§ _mul_loaded

§ _mul_ready

§ _op1

§ _op2

§ _reg_mac

§ _reg_mul

§ _remaining

§ _sig_burst_size

§ _sig_dma_prog

§ _sig_nn_size

§ _sig_out_size

§ _sig_stall

§ nn_size

§ out_size