-
Notifications
You must be signed in to change notification settings - Fork 181
/
params.go
123 lines (103 loc) · 3.99 KB
/
params.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
package simulation
import (
"encoding/json"
"fmt"
"math/rand"
"github.com/okex/exchain/libs/cosmos-sdk/codec"
sdk "github.com/okex/exchain/libs/cosmos-sdk/types"
govtypes "github.com/okex/exchain/libs/cosmos-sdk/x/gov/types"
)
const (
// Minimum time per block
minTimePerBlock int64 = 10000 / 2
// Maximum time per block
maxTimePerBlock int64 = 10000
)
// TODO: explain transitional matrix usage
var (
// Currently there are 3 different liveness types,
// fully online, spotty connection, offline.
defaultLivenessTransitionMatrix, _ = CreateTransitionMatrix([][]int{
{90, 20, 1},
{10, 50, 5},
{0, 10, 1000},
})
// 3 states: rand in range [0, 4*provided blocksize],
// rand in range [0, 2 * provided blocksize], 0
defaultBlockSizeTransitionMatrix, _ = CreateTransitionMatrix([][]int{
{85, 5, 0},
{15, 92, 1},
{0, 3, 99},
})
)
// AppParams defines a flat JSON of key/values for all possible configurable
// simulation parameters. It might contain: operation weights, simulation parameters
// and flattened module state parameters (i.e not stored under it's respective module name).
type AppParams map[string]json.RawMessage
// ParamSimulator creates a parameter value from a source of random number
type ParamSimulator func(r *rand.Rand)
// GetOrGenerate attempts to get a given parameter by key from the AppParams
// object. If it exists, it'll be decoded and returned. Otherwise, the provided
// ParamSimulator is used to generate a random value or default value (eg: in the
// case of operation weights where Rand is not used).
func (sp AppParams) GetOrGenerate(cdc *codec.Codec, key string, ptr interface{}, r *rand.Rand, ps ParamSimulator) {
if v, ok := sp[key]; ok && v != nil {
cdc.MustUnmarshalJSON(v, ptr)
return
}
ps(r)
}
// ContentSimulatorFn defines a function type alias for generating random proposal
// content.
type ContentSimulatorFn func(r *rand.Rand, ctx sdk.Context, accs []Account) govtypes.Content
// Params define the parameters necessary for running the simulations
type Params struct {
PastEvidenceFraction float64
NumKeys int
EvidenceFraction float64
InitialLivenessWeightings []int
LivenessTransitionMatrix TransitionMatrix
BlockSizeTransitionMatrix TransitionMatrix
}
// RandomParams returns random simulation parameters
func RandomParams(r *rand.Rand) Params {
return Params{
PastEvidenceFraction: r.Float64(),
NumKeys: RandIntBetween(r, 2, 2500), // number of accounts created for the simulation
EvidenceFraction: r.Float64(),
InitialLivenessWeightings: []int{RandIntBetween(r, 1, 80), r.Intn(10), r.Intn(10)},
LivenessTransitionMatrix: defaultLivenessTransitionMatrix,
BlockSizeTransitionMatrix: defaultBlockSizeTransitionMatrix,
}
}
//-----------------------------------------------------------------------------
// Param change proposals
// SimValFn function to generate the randomized parameter change value
type SimValFn func(r *rand.Rand) string
// ParamChange defines the object used for simulating parameter change proposals
type ParamChange struct {
Subspace string
Key string
SimValue SimValFn
}
// NewSimParamChange creates a new ParamChange instance
func NewSimParamChange(subspace, key string, simVal SimValFn) ParamChange {
return ParamChange{
Subspace: subspace,
Key: key,
SimValue: simVal,
}
}
// ComposedKey creates a new composed key for the param change proposal
func (spc ParamChange) ComposedKey() string {
return fmt.Sprintf("%s/%s", spc.Subspace, spc.Key)
}
//-----------------------------------------------------------------------------
// Proposal Contents
// WeightedProposalContent defines a common struct for proposal contents defined by
// external modules (i.e outside gov)
type WeightedProposalContent struct {
AppParamsKey string // key used to retrieve the value of the weight from the simulation application params
DefaultWeight int // default weight
ContentSimulatorFn ContentSimulatorFn // content simulator function
}