Ik ben bezig met het programmeren van mijn NAS, waarbij ik elk halfuur snapshots (=soort van back-up) laat maken van mijn bestanden (echter enkel maar wanneer er wijzigingen zijn t.o.v. voorgaande snapshot).
Om te zorgen dat het geheel een beetje beheersbaar blijven, is de laatste 24uur beschermd en worden van de laatste 3mnd maximaal 40 snapshots bewaard.
Nu ben ik op zoek naar een algoritme, wat een goede verdeling van de snapshots waarborgt. Omdat recentere meer waard zijn dan niet-recente snapshots, heb ik besloten een logaritmische verdeling over tijd aan te houden. Waarbij 0 het moment nu is, en het logaritme van het aantal verstreken seconden sinds het maken van de snapshot als waarden genomen wordt.
Één keer per dag draait er een script om te bepalen welke snapshots bewaard moeten worden en welke niet.
Om te bepalen welke snapshots wel en niet bewaard moeten worden, ben ik nu op zoek naar een algoritme die het beste bepaald welke passend zijn bij een goede verdeling.
Nu dacht ik, dit probleem komt eigenlijk neer op:
- Verzameling A (alle logaritmische waarden)
- B = minimale waarde uit verzameling A
- C = maximale waarde uit verzameling A
- N = het aantal te bewaren snapshots (in dit geval 40).
Definieer een lijn: ([1,B] => [N,C])
Selecteer D vervolgens als N-2 waarden uit verzameling A gesorteerd in oplopene volgorde, zodanig dat als ze als punten ingevoegd worden in het assenstelsel van voorgenoemde lijn ([2, D(1)], [3, D(2)], ..., [N-1,D(N-2)]) dat de afstand tussen deze punten en de lijn minimaal is.
Nu is het probleem dat als je dit met een least-squaresmethode doet je over alle combinaties moet itereren. Dat kan soms wel extreem veel combinaties opleveren.
Hierbij heb ik twee vragen:
- Is er een bekend ander probleem in het leven, waarbij een dergelijke vraag gesteld wordt? Zo ja, hoe wordt dit dan opgelost?
- Is er een efficiënter algoritme om dit probleem op te lossen?