Update.

Author: Strabox

cli/init_node.go

@@ -44,8 +44,9 @@ func initNode(hostIP, configFilePath string, join bool, joinIP string) error {
 	// Print/log the systemConfigurations values
 	systemConfigurations.Print()
 
-	// Global GUID size initialization
-	guid.Init(systemConfigurations.ChordHashSizeBits())
+	// GUID package custom initialization.
+	guid.Init(systemConfigurations.ChordHashSizeBits(), int64(systemConfigurations.GUIDEstimatedNetworkSize()),
+		int64(systemConfigurations.GUIDScaleFactor()))
 
 	// Create Overlay Component
 	overlayConfigured := overlay.Create(systemConfigurations)
@@ -59,7 +60,7 @@ func initNode(hostIP, configFilePath string, join bool, joinIP string) error {
 	// Create the API server
 	apiServer := rest.NewServer(systemConfigurations.APIPort())
 
-	// Create a CARAVELA Node passing all the external components and start it functions
+	// Create a Caravela's Node passing all the external components and start its functions.
 	thisNode := node.NewNode(systemConfigurations, overlayConfigured, caravelaCli, dockerClient, apiServer)
 
 	err = thisNode.Start(join, joinIP)

configuration.toml

@@ -10,11 +10,11 @@ Backend = "chord-single-offer"
     [Caravela.DiscoveryBackend.OfferingChordBackend]
     SupplyingInterval = "1m"
     SpreadOffersInterval = "1m"
-    RefreshesCheckInterval = "1m30s"
-    RefreshingInterval = "1m"
+    RefreshingInterval = "5m"
+    RefreshesCheckInterval = "5m30s"
+    RefreshMissedTimeout = "1m"
     MaxRefreshesFailed = 3
     MaxRefreshesMissed = 2
-    RefreshMissedTimeout = "1m30s"
     [Caravela.DiscoveryBackend.RandomChordBackend]
     RandBackendMaxRetries = 3
 [Caravela.Resources]

configuration/configuration.go

@@ -69,8 +69,10 @@ type offeringChordDiscBackend struct {
 	MaxRefreshesFailed     int      `json:"MaxRefreshesFailed"`     // Maximum amount of refreshes that a supplier failed to reply
 	MaxRefreshesMissed     int      `json:"MaxRefreshesMissed"`     // Maximum amount of refreshes a trader failed to send to the supplier
 	// Debug performance flags
-	SpreadOffers          bool `json:"SpreadOffers"`          // Used to tell if the spread offers mechanism is used or not.
-	SpreadPartitionsState bool `json:"SpreadPartitionsState"` // Used to tell if the spread partitions state is used or not.
+	SpreadOffers             bool `json:"SpreadOffers"`             // Used to tell if the spread offers mechanism is used or not.
+	SpreadPartitionsState    bool `json:"SpreadPartitionsState"`    // Used to tell if the spread partitions state is used or not.
+	GUIDEstimatedNetworkSize int  `json:"GUIDEstimatedNetworkSize"` // Estimated network size to tune the GUID scale.
+	GUIDScaleFactor          int  `json:"GUIDScaleFactor"`          // GUID scale's factor.
 }
 
 type randomChordDiscBackend struct {
@@ -132,8 +134,10 @@ func Default(hostIP string) *Configuration {
 					MaxRefreshesMissed:     2,
 					RefreshMissedTimeout:   duration{Duration: refreshingInterval.Duration + (5 * time.Second)},
 					// Debug performance flags
-					SpreadOffers:          true,
-					SpreadPartitionsState: true,
+					SpreadOffers:             true,
+					SpreadPartitionsState:    true,
+					GUIDEstimatedNetworkSize: 50000,
+					GUIDScaleFactor:          5,
 				},
 				RandomChordBackend: randomChordDiscBackend{
 					RandBackendMaxRetries: 6,
@@ -271,6 +275,14 @@ func (c *Configuration) validate() error {
 		return fmt.Errorf("maximum number of missed refreshes must be a positive integer")
 	}
 
+	if c.GUIDEstimatedNetworkSize() <= 0 {
+		return fmt.Errorf("estimated network size must a positive integer")
+	}
+
+	if c.GUIDScaleFactor() <= 0 {
+		return fmt.Errorf("GUID scale factor must a positive integer")
+	}
+
 	// ======================= Random Chord Discovery Backend specific ==========================
 
 	if c.RandBackendMaxRetries() <= 0 {
@@ -316,7 +328,7 @@ func (c *Configuration) Print() {
 	log.Printf("Messages Timeout:            %s", c.APITimeout().String())
 	log.Printf("CPU Slices:                  %d", c.CPUSlices())
 	log.Printf("CPU Overcommit:              %d", c.CPUOvercommit())
-	log.Printf("Memory Overcommit:              %d", c.MemoryOvercommit())
+	log.Printf("Memory Overcommit:           %d", c.MemoryOvercommit())
 	log.Printf("Scheduling Policy:           %s", c.SchedulingPolicy())
 	log.Printf("FreeResources Partitions:")
 	for _, powerPart := range c.Caravela.Resources.CPUClasses {
@@ -341,8 +353,11 @@ func (c *Configuration) Print() {
 	log.Printf("      Refresh missed timeout:        %s", c.RefreshMissedTimeout().String())
 	log.Printf("      Max num of refreshes failed:   %d", c.MaxRefreshesFailed())
 	log.Printf("      Max num of refreshes missed:   %d", c.MaxRefreshesMissed())
+	// Debug performance flags.
 	log.Printf("      Spread Offers:                 %t", c.SpreadOffers())
 	log.Printf("      Spread Partitions State:       %t", c.SpreadPartitionsState())
+	log.Printf("      GUID Estimated Network Size:   %d", c.GUIDEstimatedNetworkSize())
+	log.Printf("      GUID Scale Factor:             %d", c.GUIDScaleFactor())
 
 	log.Printf("$$$$$$$$$$$$$$$$$$$$$$$ IMAGES STORAGE $$$$$$$$$$$$$$$$$$$$$$$$$$$")
 	log.Printf("Active Storage Backend:              %s", c.ImagesStorageBackend())
@@ -440,14 +455,26 @@ func (c *Configuration) RefreshMissedTimeout() time.Duration {
 	return c.Caravela.DiscoveryBackend.OfferingChordBackend.RefreshMissedTimeout.Duration
 }
 
+// Debug performance flag.
 func (c *Configuration) SpreadOffers() bool {
 	return c.Caravela.DiscoveryBackend.OfferingChordBackend.SpreadOffers
 }
 
+// Debug performance flag.
 func (c *Configuration) SpreadPartitionsState() bool {
 	return c.Caravela.DiscoveryBackend.OfferingChordBackend.SpreadPartitionsState
 }
 
+// Debug performance flag.
+func (c *Configuration) GUIDEstimatedNetworkSize() int {
+	return c.Caravela.DiscoveryBackend.OfferingChordBackend.GUIDEstimatedNetworkSize
+}
+
+// Debug performance flag.
+func (c *Configuration) GUIDScaleFactor() int {
+	return c.Caravela.DiscoveryBackend.OfferingChordBackend.GUIDScaleFactor
+}
+
 // =================== Random Chord Discovery Backend specific ==============
 
 func (c *Configuration) RandBackendMaxRetries() int {

node/common/guid/guid.go

@@ -18,16 +18,27 @@ var isGUIDInitialized = false
 // 160-bits default (To maintain compatibility with used chord overlay implementation)
 var guidSizeBits = 160
 
+// ...
+var scaleGUIDStep *big.Int = nil
+
 // GUID represents a Global Unique Identifier (GUID) for a system's node
 type GUID struct {
 	id *big.Int
 }
 
 // Init initializes the GUID package with the size of the GUID.
-func Init(guidBitsSize int) {
+func Init(guidBitsSize int, estimatedGUIDs, scaleFactor int64) {
 	if !isGUIDInitialized {
+		// Initialize the GUID size.
 		guidSizeBits = guidBitsSize
 		isGUIDInitialized = true
+
+		// Initialize the GUID scale step.
+		maxGUID := MaximumGUID()
+		tempBigInt := big.NewInt(0)
+		tempBigInt.Div(maxGUID.id, big.NewInt(estimatedGUIDs))
+		tempBigInt.Mul(tempBigInt, big.NewInt(scaleFactor))
+		scaleGUIDStep = tempBigInt
 	}
 }
 
@@ -105,27 +116,19 @@ func newGUIDBigInt(bytesID *big.Int) *GUID {
 	return guid
 }
 
-func scaleWindow() *big.Int {
-	maxGUID := MaximumGUID()
-
-	tempBigInt := big.NewInt(0)
-	tempBigInt.Div(maxGUID.id, big.NewInt(10000))
-	tempBigInt.Mul(tempBigInt, big.NewInt(5))
-
-	return tempBigInt
-}
-
-// GenerateInnerRandomGUIDV2 ...
-func (g *GUID) GenerateInnerRandomGUIDV2(topGUID GUID) (*GUID, error) {
+// GenerateInnerRandomGUIDScaled generates a random GUID that belongs to the interval [this, topGUID).
+// But it returns one of a specific set of GUIDs from the interval. This set is small than the total GUIDs of
+// the interval.
+func (g *GUID) GenerateInnerRandomGUIDScaled(topGUID GUID) (*GUID, error) {
 	dif := big.NewInt(0)
 
 	dif.Sub(topGUID.id, g.id)
 
-	dif.Div(dif, scaleWindow())
+	dif.Div(dif, scaleGUIDStep)
 
 	dif.Rand(randomGenerator, dif)
 
-	dif.Mul(dif, scaleWindow())
+	dif.Mul(dif, scaleGUIDStep)
 
 	dif.Add(g.id, dif)
 

node/common/guid/range.go

@@ -20,7 +20,7 @@ func NewGUIDRange(lowerGUID GUID, higherGUID GUID) *Range {
 
 // GenerateRandom generate random GUID inside the range.
 func (r *Range) GenerateRandom() (*GUID, error) {
-	return r.lowerGUID.GenerateInnerRandomGUIDV2(*r.higherGUID)
+	return r.lowerGUID.GenerateInnerRandomGUIDScaled(*r.higherGUID)
 }
 
 // CreatePartitions returns partitions, set of ranges, of the receiver range.