access

package
v0.0.0-...-ea60fba Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 16, 2024 License: GPL-3.0 Imports: 2 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Init 

func Init(bw int64)

bw is the busWidth.

Types

type Access 

type Access interface {
	GetRegCount() int64 // Number of occupied registers.
	GetStartAddr() int64
	GetEndAddr() int64
	GetStartBit() int64
	GetEndBit() int64
	GetWidth() int64         // Total width of single functionality.
	GetStartRegWidth() int64 // Width occupied in the first register.
	GetEndRegWidth() int64   // Width occupied in the last register.
}

func MakeArrayNInReg 

func MakeArrayNInReg(itemCount, startAddr, width int64) Access

MakeArrayNInReg makes ArrayNInReg starting from bit 0, and placing as many items within single register as possible.

func MakeArrayNInRegMInEndReg 

func MakeArrayNInRegMInEndReg(itemCount, startAddr, width int64) Access

MakeArrayNInRegMInEndReg makes ArrayNInRegMInEndReg starting from bit 0, and placing as many items within single register as possible.

func MakeArrayNRegs 

func MakeArrayNRegs(itemCount, startAddr, startBit, width int64) Access

func MakeArrayOneInNRegs 

func MakeArrayOneInNRegs(itemCount, startAddr, width int64) Access

MakeArrayOneInNRegs makes ArrayNInRegMInEndReg starting from bit 0, and placing as many items within single register as possible.

func MakeSingle 

func MakeSingle(addr, startBit, width int64) Access

MakeSingle makes SingleOneReg or SingleNRegs depending on the argument values.

func MakeSingleNRegs 

func MakeSingleNRegs(addr, startBit, width int64) Access

func MakeSingleOneReg 

func MakeSingleOneReg(addr, startBit, width int64) Access

type ArrayNInReg 

type ArrayNInReg struct {
	Type       string
	RegCount   int64
	ItemCount  int64
	ItemWidth  int64
	ItemsInReg int64
	StartAddr  int64
	StartBit   int64
}

ArrayNInReg describes an access to an array of functionalities with multiple functionalities placed within single register. 

Example:

c [6]config; width = 15

            Reg N                         Reg N+1                        Reg N+2
------------------------------ ------------------------------ ------------------------------
|| c[0] | c[1] | 2 bits gap || || c[2] | c[3] | 2 bits gap || || c[4] | c[5] | 2 bits gap ||
------------------------------ ------------------------------ ------------------------------

func (ArrayNInReg) GetEndAddr 

func (anir ArrayNInReg) GetEndAddr() int64

func (ArrayNInReg) GetEndBit 

func (anir ArrayNInReg) GetEndBit() int64

func (ArrayNInReg) GetEndRegWidth 

func (anir ArrayNInReg) GetEndRegWidth() int64

func (ArrayNInReg) GetRegCount 

func (anir ArrayNInReg) GetRegCount() int64

func (ArrayNInReg) GetStartAddr 

func (anir ArrayNInReg) GetStartAddr() int64

func (ArrayNInReg) GetStartBit 

func (anir ArrayNInReg) GetStartBit() int64

func (ArrayNInReg) GetStartRegWidth 

func (anir ArrayNInReg) GetStartRegWidth() int64

func (ArrayNInReg) GetWidth 

func (anir ArrayNInReg) GetWidth() int64

type ArrayNInRegMInEndReg 

type ArrayNInRegMInEndReg struct {
	Type          string
	RegCount      int64
	ItemCount     int64
	ItemWidth     int64
	ItemsInReg    int64
	ItemsInEndReg int64
	StartAddr     int64
	StartBit      int64
}

ArrayNInRegMInEndReg describes an access to an array of functionalities with multiple functionalities placed within single register. 

Example:

c [5]config; width = 15

            Reg N                         Reg N+1                     Reg N+2
------------------------------ ------------------------------ ------------------------
|| c[0] | c[1] | 2 bits gap || || c[2] | c[3] | 2 bits gap || || c[4] | 17 bits gap ||
------------------------------ ------------------------------ ------------------------

func (ArrayNInRegMInEndReg) GetEndAddr 

func (anm ArrayNInRegMInEndReg) GetEndAddr() int64

func (ArrayNInRegMInEndReg) GetEndBit 

func (anm ArrayNInRegMInEndReg) GetEndBit() int64

func (ArrayNInRegMInEndReg) GetEndRegWidth 

func (anm ArrayNInRegMInEndReg) GetEndRegWidth() int64

func (ArrayNInRegMInEndReg) GetRegCount 

func (anm ArrayNInRegMInEndReg) GetRegCount() int64

func (ArrayNInRegMInEndReg) GetStartAddr 

func (anm ArrayNInRegMInEndReg) GetStartAddr() int64

func (ArrayNInRegMInEndReg) GetStartBit 

func (anm ArrayNInRegMInEndReg) GetStartBit() int64

func (ArrayNInRegMInEndReg) GetStartRegWidth 

func (anm ArrayNInRegMInEndReg) GetStartRegWidth() int64

func (ArrayNInRegMInEndReg) GetWidth 

func (anm ArrayNInRegMInEndReg) GetWidth() int64

type ArrayNRegs 

type ArrayNRegs struct {
	Type      string
	RegCount  int64
	ItemCount int64
	ItemWidth int64
	StartAddr int64
	StartBit  int64
}

ArrayNRegs describes an access to an array of functionalities with single functionality placed within multiple continuous registers. 

Example:

p [4]param; width = 14

           Reg N                        Reg N+1
--------------------------- ---------------------------------
|| p[0] | p[1] | p[2](0) || || p[2](1) | p[3] | 8 bits gap ||
--------------------------- ---------------------------------

func (ArrayNRegs) GetEndAddr 

func (anr ArrayNRegs) GetEndAddr() int64

func (ArrayNRegs) GetEndBit 

func (anr ArrayNRegs) GetEndBit() int64

func (ArrayNRegs) GetEndRegWidth 

func (anr ArrayNRegs) GetEndRegWidth() int64

func (ArrayNRegs) GetRegCount 

func (anr ArrayNRegs) GetRegCount() int64

func (ArrayNRegs) GetStartAddr 

func (anr ArrayNRegs) GetStartAddr() int64

func (ArrayNRegs) GetStartBit 

func (anr ArrayNRegs) GetStartBit() int64

func (ArrayNRegs) GetStartRegWidth 

func (anr ArrayNRegs) GetStartRegWidth() int64

func (ArrayNRegs) GetWidth 

func (anr ArrayNRegs) GetWidth() int64

type ArrayOneInNRegs 

type ArrayOneInNRegs struct {
	Type      string
	ItemCount int64
	ItemWidth int64
	StartAddr int64
}

ArrayOneInNRegs describes an access to an array of functionalities with one functionality placed in N registers. Start bit is always 0. 

Example:

c [2]config; width = 33

    Reg N               Reg N+1              Reg N+2              Reg N+3
------------- --------------------------- ------------- ---------------------------
|| c[0](0) || || c[0](1) | 31 bits gap || || c[1](0) || || c[1](1) | 31 bits gap ||
------------- --------------------------- ------------- ---------------------------

func (ArrayOneInNRegs) GetEndAddr 

func (aoinr ArrayOneInNRegs) GetEndAddr() int64

func (ArrayOneInNRegs) GetEndBit 

func (aoinr ArrayOneInNRegs) GetEndBit() int64

func (ArrayOneInNRegs) GetEndRegWidth 

func (aoinr ArrayOneInNRegs) GetEndRegWidth() int64

func (ArrayOneInNRegs) GetRegCount 

func (aoinr ArrayOneInNRegs) GetRegCount() int64

func (ArrayOneInNRegs) GetRegsPerItem 

func (aoinr ArrayOneInNRegs) GetRegsPerItem() int64

func (ArrayOneInNRegs) GetStartAddr 

func (aoinr ArrayOneInNRegs) GetStartAddr() int64

func (ArrayOneInNRegs) GetStartBit 

func (aoinr ArrayOneInNRegs) GetStartBit() int64

func (ArrayOneInNRegs) GetStartRegWidth 

func (aoinr ArrayOneInNRegs) GetStartRegWidth() int64

func (ArrayOneInNRegs) GetWidth 

func (aoinr ArrayOneInNRegs) GetWidth() int64

type ArrayOneInReg 

type ArrayOneInReg struct {
	Type      string
	RegCount  int64
	StartAddr int64
	StartBit  int64
	EndBit    int64
}

ArraySingle describes an access to an array of functionalities with single item placed within single register. 

Example:

c [3]config; width = 25

         Reg N                  Reg N+1                Reg N+2
----------------------- ----------------------- -----------------------
|| c[0] | 7 bits gap || || c[1] | 7 bits gap || || c[2] | 7 bits gap ||
----------------------- ----------------------- -----------------------

func MakeArrayOneInReg 

func MakeArrayOneInReg(itemCount, addr, startBit, width int64) ArrayOneInReg

func (ArrayOneInReg) GetEndAddr 

func (aoir ArrayOneInReg) GetEndAddr() int64

func (ArrayOneInReg) GetEndBit 

func (aoir ArrayOneInReg) GetEndBit() int64

func (ArrayOneInReg) GetEndRegWidth 

func (aoir ArrayOneInReg) GetEndRegWidth() int64

func (ArrayOneInReg) GetRegCount 

func (aoir ArrayOneInReg) GetRegCount() int64

func (ArrayOneInReg) GetStartAddr 

func (aoir ArrayOneInReg) GetStartAddr() int64

func (ArrayOneInReg) GetStartBit 

func (aoir ArrayOneInReg) GetStartBit() int64

func (ArrayOneInReg) GetStartRegWidth 

func (aoir ArrayOneInReg) GetStartRegWidth() int64

func (ArrayOneInReg) GetWidth 

func (aoir ArrayOneInReg) GetWidth() int64

type ArrayOneReg 

type ArrayOneReg struct {
	Type      string
	Addr      int64
	StartBit  int64
	ItemWidth int64
	ItemCount int64
}

ArrayOneReg describes an access to an array of functionalities with all items placed in one register. 

Example:

s [4]status; width = 7

                   Reg N
--------------------------------------------
|| s[0] | s[1] | s[2] | s[3] | 4 bits gap ||
--------------------------------------------

func MakeArrayOneReg 

func MakeArrayOneReg(itemCount, addr, startBit, width int64) ArrayOneReg

func (ArrayOneReg) GetEndAddr 

func (aor ArrayOneReg) GetEndAddr() int64

func (ArrayOneReg) GetEndBit 

func (aor ArrayOneReg) GetEndBit() int64

func (ArrayOneReg) GetEndRegWidth 

func (aor ArrayOneReg) GetEndRegWidth() int64

func (ArrayOneReg) GetRegCount 

func (aor ArrayOneReg) GetRegCount() int64

func (ArrayOneReg) GetStartAddr 

func (aor ArrayOneReg) GetStartAddr() int64

func (ArrayOneReg) GetStartBit 

func (aor ArrayOneReg) GetStartBit() int64

func (ArrayOneReg) GetStartRegWidth 

func (aor ArrayOneReg) GetStartRegWidth() int64

func (ArrayOneReg) GetWidth 

func (aor ArrayOneReg) GetWidth() int64

type SingleNRegs 

type SingleNRegs struct {
	Type      string
	RegCount  int64
	StartAddr int64 // Address of the first register.
	StartBit  int64
	EndBit    int64
}

SingleNRegs describes an access to a single functionality placed within multiple continuous registers. 

Example:

c config; width = 72

  Reg N     Reg N+1           Reg N+2
---------- ---------- ------------------------
|| c(0) || || c(1) || || c(2) | 24 bits gap ||
---------- ---------- ------------------------

func (SingleNRegs) GetEndAddr 

func (snr SingleNRegs) GetEndAddr() int64

func (SingleNRegs) GetEndBit 

func (snr SingleNRegs) GetEndBit() int64

func (SingleNRegs) GetEndRegWidth 

func (snr SingleNRegs) GetEndRegWidth() int64

func (SingleNRegs) GetRegCount 

func (snr SingleNRegs) GetRegCount() int64

func (SingleNRegs) GetStartAddr 

func (snr SingleNRegs) GetStartAddr() int64

func (SingleNRegs) GetStartBit 

func (snr SingleNRegs) GetStartBit() int64

func (SingleNRegs) GetStartRegWidth 

func (snr SingleNRegs) GetStartRegWidth() int64

func (SingleNRegs) GetWidth 

func (snr SingleNRegs) GetWidth() int64

func (SingleNRegs) IsEndRegWider 

func (snr SingleNRegs) IsEndRegWider() bool

IsEndRegWider returns true if end register is wider than the start one.

type SingleOneReg 

type SingleOneReg struct {
	Type     string
	Addr     int64
	StartBit int64
	EndBit   int64
}

SingleOneReg describes an access to a single functionality placed within single register. 

Example:

s status; width = 23

       Reg N
--------------------
|| s | 9 bits gap ||
--------------------

func (SingleOneReg) GetEndAddr 

func (sor SingleOneReg) GetEndAddr() int64

func (SingleOneReg) GetEndBit 

func (sor SingleOneReg) GetEndBit() int64

func (SingleOneReg) GetEndRegWidth 

func (sor SingleOneReg) GetEndRegWidth() int64

func (SingleOneReg) GetRegCount 

func (sor SingleOneReg) GetRegCount() int64

func (SingleOneReg) GetStartAddr 

func (sor SingleOneReg) GetStartAddr() int64

func (SingleOneReg) GetStartBit 

func (sor SingleOneReg) GetStartBit() int64

func (SingleOneReg) GetStartRegWidth 

func (sor SingleOneReg) GetStartRegWidth() int64

func (SingleOneReg) GetWidth 

func (sor SingleOneReg) GetWidth() int64

type Sizes 

type Sizes struct {
	BlockAligned, Compact, Own int64
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.