Use etl::vector and sort for patcher

SynthstromAudible · Feb 11, 2025 · e4ce3c8 · e4ce3c8
1 parent 00e86e9
commit e4ce3c8
Show file tree

Hide file tree

Showing 3 changed files with 39 additions and 34 deletions.
diff --git a/src/deluge/modulation/patch/patcher.cpp b/src/deluge/modulation/patch/patcher.cpp
@@ -21,7 +21,7 @@
 #include "modulation/patch/patch_cable.h"
 #include "modulation/patch/patch_cable_set.h"
 #include "processing/sound/sound.h"
-#include <etl/map.h>
+#include <etl/vector.h>
 #include <utility>
 
 namespace params = deluge::modulation::params;
@@ -85,7 +85,7 @@ void Patcher::performPatching(uint32_t sourcesChanged, Sound& sound, ParamManage
 	}
 
 	// param_id, cable_combo
-	etl::map<int32_t, int32_t, params::kNumParams> cable_combos;
+	etl::vector<std::pair<int32_t, int32_t>, params::kNumParams> cable_combos;
 
 	// Now normal, actual params/destinations
 	for (; destination->destinationParamDescriptor.data < (config.firstHybridParam | 0xFFFFFF00); destination++) {
@@ -94,44 +94,49 @@ void Patcher::performPatching(uint32_t sourcesChanged, Sound& sound, ParamManage
 		}
 
 		int32_t param = destination->destinationParamDescriptor.getJustTheParam();
-		cable_combos[param] = combineCablesLinear(destination, param, sound, param_manager);
+		cable_combos.push_back({param, combineCablesLinear(destination, param, sound, param_manager)});
 	}
 
 	for (; destination->sources != 0u; destination++) {
 		if ((destination->sources & sourcesChanged) == 0u) {
 			continue;
 		}
 
-		int32_t p = destination->destinationParamDescriptor.getJustTheParam();
-		cable_combos[p] = combineCablesExp(destination, p, sound, param_manager);
+		int32_t param = destination->destinationParamDescriptor.getJustTheParam();
+		cable_combos.push_back({param, combineCablesExp(destination, param, sound, param_manager)});
 	}
 
-	// Now, turn those cableCombinations into paramFinalValues. Splitting these up like this caused a massive speed-up
-	// on all presets tested, somewhat surprisingly!
-	for (auto& [param, cable_combo] : cable_combos) {
-		// Volume params
-		if (param < config.firstNonVolumeParam) {
-			param_final_values_[param - config.firstParam] =
-			    getFinalParameterValueVolume(paramNeutralValues[param], cable_combo);
-		}
+	// sort by param_id
+	std::ranges::sort(cable_combos, std::less(), &std::pair<int32_t, int32_t>::first);
 
-		// Linear params
-		else if (param < config.firstHybridParam) {
-			param_final_values_[param - config.firstParam] =
-			    getFinalParameterValueLinear(paramNeutralValues[param], cable_combo);
-		}
+	auto* iterator = cable_combos.begin();
 
-		// Hybrid params
-		else if (param < config.firstExpParam) {
-			param_final_values_[param - config.firstParam] =
-			    getFinalParameterValueHybrid(paramNeutralValues[param], cable_combo);
-		}
+	// Now, turn those cableCombinations into paramFinalValues.
+	// Volume params
+	for (; iterator->first < config.firstNonVolumeParam; iterator++) {
+		auto [param, combo] = *iterator;
+		param_final_values_[param - config.firstParam] = getFinalParameterValueVolume(paramNeutralValues[param], combo);
+	}
 
-		// Exp params
-		else {
-			param_final_values_[param - config.firstParam] =
-			    getFinalParameterValueExpWithDumbEnvelopeHack(paramNeutralValues[param], cable_combo, param);
-		}
+	// Linear params
+	for (; iterator->first < config.firstHybridParam; iterator++) {
+		auto [param, cable_combo] = *iterator;
+		param_final_values_[param - config.firstParam] =
+		    getFinalParameterValueLinear(paramNeutralValues[param], cable_combo);
+	}
+
+	// Hybrid params
+	for (; iterator->first < config.firstExpParam; iterator++) {
+		auto [param, cable_combo] = *iterator;
+		param_final_values_[param - config.firstParam] =
+		    getFinalParameterValueHybrid(paramNeutralValues[param], cable_combo);
+	}
+
+	// Exp params
+	for (; iterator < cable_combos.end(); iterator++) {
+		auto [param, cable_combo] = *iterator;
+		param_final_values_[param - config.firstParam] =
+		    getFinalParameterValueExpWithDumbEnvelopeHack(paramNeutralValues[param], cable_combo, param);
 	}
 }
 

diff --git a/src/deluge/modulation/patch/patcher.h b/src/deluge/modulation/patch/patcher.h
@@ -59,12 +59,12 @@ class Patcher {
 	int32_t combineCablesExp(Destination const* destination, uint32_t param, Sound& sound, ParamManager& param_manager);
 	static int32_t cableToLinearParamWithoutRangeAdjustment(int32_t running_total, int32_t source_value,
 	                                                        int32_t cable_strength);
-	int32_t cableToLinearParam(int32_t running_total, const PatchCable& cable, int32_t source_value,
-	                           int32_t cable_strength);
+	static int32_t cableToLinearParam(int32_t running_total, const PatchCable& cable, int32_t source_value,
+	                                  int32_t cable_strength);
 	static int32_t cableToExpParamWithoutRangeAdjustment(int32_t running_total, int32_t source_value,
 	                                                     int32_t cable_strength);
-	int32_t cableToExpParam(int32_t running_total, const PatchCable& cable, int32_t source_value,
-	                        int32_t cable_strength);
+	static int32_t cableToExpParam(int32_t running_total, const PatchCable& cable, int32_t source_value,
+	                               int32_t cable_strength);
 
 	const Config& config;
 	std::span<int32_t> source_values_;

diff --git a/src/deluge/util/functions.cpp b/src/deluge/util/functions.cpp
@@ -226,8 +226,8 @@ int32_t getFinalParameterValueVolume(int32_t paramNeutralValue, int32_t patchedV
 
 int32_t getFinalParameterValueLinear(int32_t paramNeutralValue, int32_t patchedValue) {
 
-	// patchedValue's range is ideally +- 536870912, but may get up to 1610612736 due to multiple patch cables having
-	// been multiplied
+	// patchedValue's range is ideally +- 536870912 ('1'), but may get up to 1610612736 ('3') due to multiple patch
+	// cables having been multiplied
 
 	// No need for max/min here - it's already been taken care of in patchAllCablesToParameter(),
 	// ... or if we got here from patchSourceToAllExclusiveCables(), there's no way it could have been too big