mrnesbits

type CPInitList struct {
	// label of the Computation Pattern whose Funcs are being initialized
	Name string `json:"name" yaml:"name"`

	// CPType of CP being initialized
	CPType string `json:"cptype" yaml:"cptype"`

	// UseYAML flags whether to interpret the seriaized initialization structure using json or yaml
	UseYAML bool `json:"useyaml" yaml:"useyaml"`

	// Params is indexed by Func label, mapping to a serialized representation of a struct
	Params map[string]string `json:"params" yaml:"params"`

	// Params is indexed by Func label, mapping to a serialized representation of a struct
	State map[string]string `json:"state" yaml:"state"`

	// Msgs holds a list of CompPatternMsgs used between Funcs in a CompPattern
	Msgs []CompPatternMsg `json:"msgs" yaml:"msgs"`
}

type CPInitListDict struct {
	Prebuilt bool   `json:"prebuilt" yaml:"prebuilt"`
	DictName string `json:"dictname" yaml:"dictname"`

	// indexed by name of comp pattern
	InitList map[string]CPInitList `json:"initlist" yaml:"initlist"`
}

type CmpPtnFuncInst struct {
	InitFunc evtm.EventHandlerFunction // if not 'emptyInitFunc' call this to initialize the function
	InitMsg  *CmpPtnMsg                // message that is copied when this instance is used to initiate a chain of func evaluations

	Label string // an identifier for this func, unique within the instance of CompPattern holding it.

	PtnName string // name of the instantiated CompPattern holding this function

	State            any     // holds string-coded state for string-code state variable names
	Reflect          bool    // whether the direction of the cmpHdr be return
	InterarrivalDist string  // for self-initiation
	InterarrivalMean float64 // for self-initiation

	// at run-time start-up this function is initialized with its responses
	// the set of potential output edges may be constrained, but not statefulermined solely by the input edge as with the static model.
	// Here, for a given input edge, 'resp' holds a slice of possible responses.
	Resp map[InEdge][]funcOutEdge
	// contains filtered or unexported fields
}

type CmpPtnGraph struct {

	// every instance a function has a string 'label', used here to index to
	// data structure that describes it and the connections it has with other funcs
	Nodes map[string]*CmpPtnGraphNode
}

type CmpPtnGraphEdge struct {
	SrcLabel  string
	MsgType   string
	DstLabel  string
	EdgeLabel string
}

type CmpPtnGraphNode struct {
	Label    string
	InEdges  []*CmpPtnGraphEdge
	OutEdges []*CmpPtnGraphEdge
}

type CmpPtnInst struct {
	Rngs  *rngstream.RngStream
	Graph *CmpPtnGraph // graph describing structure of funcs and edges
	// contains filtered or unexported fields
}

type CmpPtnMsg struct {
	ExecID int    // initialize when with an initating comp pattern message.  Carried by every resulting message.
	SrcCP  string // name of comp pattern instance from which the message originates
	DstCP  string // name of comp pattern instance to which the message is directed

	// what essential role does 'Edge' convey?
	Edge CmpPtnGraphEdge

	// do we need/want CmpHdr?
	CmpHdr EndPts

	MsgType string  // describes function of message
	MsgLen  int     // number of bytes
	PcktLen int     // parameter impacting execution time
	Rate    float64 // when non-zero, a rate limiting attribute that might used, e.g., in modeling IO
	Payload any     // free for "something else" to carry along and be used in decision logic
}

type CompPattern struct {
	// a model may use a number of instances of CompPatterns that have the same CPType
	CPType string `json:"cptype" yaml:"cptype"`

	// per-instance name of the pattern template
	Name string `json:"name" yaml:"name"`

	// instances of functions indexed by unique-to-pattern label
	Funcs []Func `json:"funcs" yaml:"funcs"`

	// description of edges in Pattern graph
	Edges []PatternEdge `json:"edges" yaml:"edges"`
}

type CompPatternDict struct {
	Prebuilt bool                   `json:"prebuilt" yaml:"prebuilt"`
	DictName string                 `json:"dictname" yaml:"dictname"`
	Patterns map[string]CompPattern `json:"patterns" yaml:"patterns"`
}

type CompPatternMap struct {
	// PatternName identifies the name of the pattern instantiation being mapped
	PatternName string `json:"patternname" yaml:"patternname"`

	// mapping of func labels to hosts. Key is Label attribute of Func
	FuncMap map[string]string `json:"funcmap" yaml:"funcmap"`
}

type CompPatternMapDict struct {
	DictName string                    `json:"dictname" yaml:"dictname"`
	Map      map[string]CompPatternMap `json:"map" yaml:"map"`
}

type CompPatternMsg struct {
	// edges in the CompPattern graph are labeled with MsgType, which means that a message across the edge must match in this attribute
	MsgType string `json:"msgtype" yaml:"msgtype"`

	// a message may be a packet or a flow
	IsPckt bool `json:"ispckt" yaml:"ispckt"`

	// PcktLen is a parameter used by some functions to select their execution time.  Not the same as the length of the message carrying the packet
	PcktLen int `json:"pcktlen" yaml:"pcktlen"`

	// MsgLen is the total length of the message c
	MsgLen int `json:"msglen" yaml:"msglen"`
}

type EndPts struct {
	SrtLabel string
	EndLabel string
}

type ExpCfg struct {
	// Name is an identifier for a group of [ExpParameters].  No particular interpretation of this string is
	// used, except as a referencing label when moving an ExpCfg into or out of a dictionary
	Name string `json:"expname" yaml:"expname"`

	// Parameters is a list of all the [ExpParameter] objects presented to the simulator for an experiment.
	Parameters []ExpParameter `json:"parameters" yaml:"parameters"`
}

type ExpCfgDict struct {
	DictName string            `json:"dictname" yaml:"dictname"`
	Cfgs     map[string]ExpCfg `json:"cfgs" yaml:"cfgs"`
}

type ExpParameter struct {
	// Type of thing being configured
	ParamObj string `json:"paramObj" yaml:"paramObj"`

	// attribute identifier for this parameter
	Attribute string `json:"attribute" yaml:"attribute"`

	// ParameterType, e.g., "Bandwidth", "WiredLatency", "CPU"
	Param string `json:"param" yaml:"param"`

	// string-encoded value associated with type
	Value string `json:"value" yaml:"value"`
}

type Func struct {
	// identifies function, e.g., encryptRSA, used to look up execution time
	Class string `json:"class" yaml:"class"`

	// particular name given to function instance within a CompPattern
	Label string `json:"label" yaml:"label"`

	// name that is globally unique within a model, used for addressing
	GblName string `json:"gblname" yaml:"gblname"`
}

type FuncClass interface {
	Class() string
	InitState(*CmpPtnFuncInst, string, bool)
}

type FuncExecDesc struct {
	Class    string  `json:"class" yaml:"class"`
	Hardware string  `json:"processortype" yaml:"processortype"`
	PcktLen  int     `json:"pcktlen" yaml:"pcktlen"`
	ExecTime float64 `json:"exectime" yaml:"exectime"`
}

type FuncExecList struct {
	// ListName is an identifier for this collection of timings
	ListName string `json:"listname" yaml:"listname"`

	// Times key is class of CompPattern function.
	// Value is list of function times for that type of function
	Times map[string][]FuncExecDesc `json:"times" yaml:"times"`
}

type FuncParameters struct {
	// Pattern is name of the CompPattern holding labeled node these parameters modify
	PatternName string `json:"patternname" yaml:"patternname"`

	// Label of function whose parameters are specified
	Label string `json:"label" yaml:"label"`

	// Global name of function whose parameters are specified
	GblName string `json:"gblname" yaml:"gblname"`

	// State variables and their initial values (string-encoded)
	State string `json:"state" yaml:"state"`

	// Response holds a list of all responses the Func may make
	Response []FuncResp `json:"response" yaml:"response"`
}

type FuncResp struct {
	// input edge
	InEdge InEdge `json:"inedge" yaml:"inedge"`

	// potential output edge
	OutEdge OutEdge `json:"outedge" yaml:"outedge"`

	// operation performed on input
	MethodCode string

	// an identifier used by the logic which chooses an output edge.
	Choice string `json:"choice" yaml:"choice"`
}

type InEdge struct {
	SrcLabel string `json:"srclabel" yaml:"srclabel"`
	MsgType  string `json:"msgtype" yaml:"msgtype"`
}

type NetSimPortal interface {
	HostCPU(string) string
	EnterNetwork(*evtm.EventManager, string, string, int, int, float64, any,
		any, evtm.EventHandlerFunction, any, evtm.EventHandlerFunction) any
}

type OutEdge struct {
	MsgType  string `json:"msgtype" yaml:"msgtype"`
	DstLabel string `json:"dstlabel" yaml:"dstlabel"`
}

type PatternEdge struct {
	SrcLabel  string `json:"srclabel" yaml:"srclabel"`
	DstLabel  string `json:"dstlabel" yaml:"dstlabel"`
	MsgType   string `json:"msgtype" yaml:"msgtype"`
	EdgeLabel string `json:"edgelabel" yaml:"edgelabel"`
}

type RespMethod struct {
	Start StartMethod
	End   evtm.EventHandlerFunction
}

type StartMethod func(*evtm.EventManager, *CmpPtnFuncInst, string,
	*CmpPtnMsg) (bool, bool, float64, []*CmpPtnMsg)

type TraceManager interface {

	// at creation a flag is set indicating whether the trace manager will be active
	Active() bool

	// add a trace event to the manager
	AddTrace(vrtime.Time, int, int, int, string, bool, float64)

	// include an id -> (name, type) pair in the trace manager dictionary
	AddName(int, string, string)

	// save the trace to file (if active) and return flag indicating whether file creatation actually happened
	WriteToFile(string) bool
}