multi: enable struct alignment check, fix for often used

For structs we use often, such as the query options, we want to have
proper alignment to save some memory space.
Other structs that we only instantiate once or a few times we don't
align in favor of better readability of the code.

Author: guggero

.golangci.yml

@@ -9,6 +9,8 @@ linters-settings:
   gofmt:
     # simplify code: gofmt with `-s` option, true by default
     simplify: true
+  maligned:
+    suggest-new: true
 
 linters:
   enable-all: true
@@ -20,9 +22,6 @@ linters:
     # even longer by marking them as 'nolint'.
     - lll
 
-    # We don't care (enough) about misaligned structs to lint that.
-    - maligned
-
     # We have long functions, especially in tests. Moving or renaming those would
     # trigger funlen problems that we may not want to solve at that time.
     - funlen

blockmanager.go

@@ -117,9 +117,9 @@ type blockManagerCfg struct {
 
 // blockManager provides a concurrency safe block manager for handling all
 // incoming blocks.
-type blockManager struct {
-	started  int32
-	shutdown int32
+type blockManager struct { // nolint:maligned
+	started  int32 // To be used atomically.
+	shutdown int32 // To be used atomically.
 
 	cfg *blockManagerCfg
 

blockntfns/manager.go

@@ -19,15 +19,16 @@ var (
 // newSubscription is an internal message used within the SubscriptionManager to
 // denote a new client's intent to receive block notifications.
 type newSubscription struct {
-	canceled sync.Once
+	id uint64 // To be used atomically.
 
-	id uint64
+	bestHeight uint32
+
+	canceled sync.Once
 
 	ntfnChan  chan BlockNtfn
 	ntfnQueue *queue.ConcurrentQueue
 
-	bestHeight uint32
-	errChan    chan error
+	errChan chan error
 
 	quit chan struct{}
 	wg   sync.WaitGroup

neutrino.go

@@ -559,7 +559,7 @@ type peerSubscription struct {
 }
 
 // ChainService is instantiated with functional options.
-type ChainService struct {
+type ChainService struct { // nolint:maligned
 	// The following variables must only be used atomically.
 	// Putting the uint64s first makes them 64-bit aligned for 32-bit systems.
 	bytesReceived uint64 // Total bytes received from all peers since start.

query.go

@@ -57,37 +57,37 @@ var (
 //
 // TODO: Make more query options that override global options.
 type queryOptions struct {
+	// maxBatchSize is the maximum items that the query should return in the
+	// case the optimisticBatch option is used. It saves bandwidth in the case
+	// the caller has a limited amount of items to fetch but still wants to use
+	// batching.
+	maxBatchSize int64
+
 	// timeout lets the query know how long to wait for a peer to answer
 	// the query before moving onto the next peer.
 	timeout time.Duration
 
-	// numRetries tells the query how many times to retry asking each peer
-	// the query.
-	numRetries uint8
-
 	// peerConnectTimeout lets the query know how long to wait for the
 	// underlying chain service to connect to a peer before giving up
 	// on a query in case we don't have any peers.
 	peerConnectTimeout time.Duration
 
+	// doneChan lets the query signal the caller when it's done, in case
+	// it's run in a goroutine.
+	doneChan chan<- struct{}
+
 	// encoding lets the query know which encoding to use when queueing
 	// messages to a peer.
 	encoding wire.MessageEncoding
 
-	// doneChan lets the query signal the caller when it's done, in case
-	// it's run in a goroutine.
-	doneChan chan<- struct{}
+	// numRetries tells the query how many times to retry asking each peer
+	// the query.
+	numRetries uint8
 
 	// optimisticBatch indicates whether we expect more calls to follow,
 	// and that we should attempt to batch more items with the query such
 	// that they can be cached, avoiding the extra round trip.
 	optimisticBatch optimisticBatchType
-
-	// maxBatchSize is the maximum items that the query should return in the
-	// case the optimisticBatch option is used. It saves bandwidth in the case
-	// the caller has a limited amount of items to fetch but still wants to use
-	// batching.
-	maxBatchSize int64
 }
 
 // optimisticBatchType is a type indicating the kind of batching we want to

rescan.go

@@ -1260,8 +1260,8 @@ txOutLoop:
 // client with updateable filters. It's meant to be close to a drop-in
 // replacement for the btcd rescan and notification functionality used in
 // wallets. It only contains information about whether a goroutine is running.
-type Rescan struct {
-	started uint32
+type Rescan struct { // nolint:maligned
+	started uint32 // To be used atomically.
 
 	running    chan struct{}
 	updateChan chan *updateOptions
@@ -1374,7 +1374,6 @@ func DisableDisconnectedNtfns(disabled bool) UpdateOption {
 
 // Update sends an update to a long-running rescan/notification goroutine.
 func (r *Rescan) Update(options ...UpdateOption) error {
-
 	ro := defaultRescanOptions()
 	for _, option := range r.options {
 		option(ro)