Menge erforderlicher Daten macht Programmierung unmöglich

[ts-soft]

Eine Exe kann nur mit einer max. Größe erstellt werden! Früher waren das mal 64 MB,
jetzige Grenze ist mir aber nicht bekannt. Also als DataSection noch Chance!

[RSBasic]

@ts-soft
Heutzutage sind es 4 GB, die maximal erlaubt sind.

[helpy]

Hallo Heinz,

Die 6 Werte pro die 16 Mio Farben werden zu Rechnungen im Lab-Farbraum benötigt. Natürlich könnte man diese
auch während der Laufzeit berechnen.

Ich würde das nicht mit DataSection machen und auch nicht mit einer externen Datei, die mit dem Programm mitgeliefert wird.

Wenn Du das Programm mit einem Setup auslieferst, wird nur das Setup unnötig aufgeblasen.

Ich würde da eher den Weg gehen, die Daten beim ersten Start des Rechners zu berechnen und dann als Datei speichern.
Diese kann dann bei jedem weiteren Start geladen und verwendet werden (das Laden wird wohl schneller gehen als das Berechnen aller Werte).

Ich weiß zwar nicht, welche Werte Du für Deine Tabelle brauchst, ich habe aber mal ein Beispiel geschrieben, das bei mir ca. 10 Sekunden braucht um alle Werte zu berechnen. Welche Werte (bzw. Berechnungen) Du für Deine Anwendung brauchst, weißt natürlich nur Du. Hier also mein Beispiel:

Code: Alles auswählen

EnableExplicit

Structure tRGBinfo
	X.f
	Y.f
	Z.f
	L.f
	a.f
	b.f
EndStructure

Define tStart = ElapsedMilliseconds()

Global Dim aRGBinfo.tRGBinfo(255,255,255)
Define R, G, B
Define.f Xn = 96.422
Define.f Yn = 100
Define.f Zn = 82.521

For R = 0 To 255
	For G = 0 To 255
		For B = 0 To 255
			With aRGBinfo(R,G,B)
				\X = 0.4124564 * R + 0.3575761 * G + 0.1804375 * B
				\Y = 0.2126729 * R + 0.7151522 * G + 0.0721750 * B
				\Z = 0.0193339 * R + 0.1191920 * G + 0.9503041 * B
				\L = 116 *   Pow(\Y / Yn, 3) - 16
				\a = 500 * ( Pow(\X / Xn, 3) - Pow(\Y / Yn, 3) )
				\b = 200 * ( Pow(\Y / Yn, 3) - Pow(\Z / Zn, 3) )
			EndWith
		Next B
	Next G
Next R

Define tEnd = ElapsedMilliseconds()
MessageRequester("","Time [ms]: " + Str(tEnd - tStart) )

Ob ein Array mit einer Struktur für Dich die optimalste Lösung ist, kann ich nicht sagen.
Das hängt davon ab, was Du alles mit den Werten machen möchtest.

Das Array braucht im Speicher ca. 400 MByte!

LG,
guido

[GPI]

Ich frag mich gerade wie du auf 1GB kommst.
Ich komm bei 256*256*256*6*8 (6 Double) komm ich auf unter 400MB.

Ich würde das ganze so lösen:

Code: Alles auswählen

UseZipPacker()
Structure gruen
  wert.f[6]
EndStructure
Structure blau
  gruen.gruen[256]
EndStructure  
Structure rot
  blau.blau[256]
EndStructure
Structure Tabelle
  rot.rot[256]
EndStructure

*buf.Tabelle=AllocateMemory(SizeOf(Tabelle))
#tabelleFile="werte.dat"
#FileID=$12345678;Irgendein Wert als ID/Versionsnummer!

#usepack=#True

Debug *buf
Debug StrF(SizeOf(Tabelle) /1024/1024,2)+" MB"
Debug SizeOf(*buf)

; Exestiert die Tabelle schon? nein-> Erstellen
If FileSize(#tabelleFile)<=0
  
  ; hier tabelle füllen
  Debug "Tabelle mit unsinn füllen"
  For i=0 To 255
    *buf\rot[i]\blau[255-i]\gruen[255]\wert[1]=i/(256.0-i)
  Next
  
  
  ; wir speichern das mal lieber als zip!
  
  Debug "speichern"
  CompilerIf #usepack
    out=CreatePack(#PB_Any,#tabelleFile,#PB_PackerPlugin_Zip)
    If out
      AddPackMemory(out,*buf,SizeOf(Tabelle),"data")
      ClosePack(out)
    EndIf
  CompilerElse
    out=CreateFile(#PB_Any,#tabelleFile)
    If out
      WriteLong(out,#FileID)
      WriteData(out,*buf,SizeOf(Tabelle))
      CloseFile(out)
    EndIf
  CompilerEndIf
  Debug "saved"
Else
  
  ;In Programm einfach laden.
  CompilerIf #usepack
    in=OpenPack(#PB_Any,#tabelleFile,#PB_PackerPlugin_Zip)
    If in
      If ExaminePack(in)
        While NextPackEntry(in)
          If PackEntryName(in)="data"
            len= UncompressPackMemory(in,*buf,SizeOf(tabelle))
            If len<>SizeOf(tabelle)
              Debug "UNCOMPRESS ERROR "+len+" "+SizeOf(tabelle)
              End
            EndIf
          EndIf
        Wend
      EndIf
      ClosePack(in)
    EndIf
  CompilerElse
    in=ReadFile(#PB_Any,#tabelleFile)
    If in
      If ReadLong(in)<>#FileID
        Debug "Veraltete Datei - man müsste hier zur erstellung springen!"
      Else
        ReadData(in,*buf,SizeOf(Tabelle))
      EndIf
      CloseFile(in)
    EndIf
  CompilerEndIf
  
  Debug "loaded"
EndIf



Debug "Check"
For i=0 To 255
  value.f=i/(256.0-i)
  If *buf\rot[i]\blau[255-i]\gruen[255]\wert[1]<>value
    Debug "DATEN FEHLERHAFT "+StrF(*buf\rot[i]\blau[255-i]\gruen[255]\wert[1]) +" "+StrF(value)
  EndIf
Next



FreeMemory(*buf)
End

Beim Start wird kontrolliert, ob die Daten-Datei exestiert, wenn nein, werden die Daten erstellt (erster Programstart dauert dann!) und dann gespeichert (je nach konstantenwert gepackt oder ungepackt). Beim zweiten Programmstart werden die Daten geladen.

Wichtig: Wenn du tatsächlich bei dir schon an der 1GB-Grenze kratzt - unbedingt die 64-Bit Version nehmen!

Edit: Und es fehlen eine Menge Fehlerabfragen. Mir gings nur ums Prinzip.

[7x7]

Ich frag mich gerade wie du auf 1GB kommst.
Ich komm bei 256*256*256*6*8 (6 Double) komm ich auf unter 400MB.

Er hat doch geschrieben, dass er die Daten in diesem "Format"....

Code: Alles auswählen

Data.f 230443,12.443432,-112.344432,0.3444324,-67.004556,-3.785545,-54.225467

...abspeichert. Diese EINE ZEILE hat schon 80 Zeichen. Das ganze mal 16777216 macht 1,34 GB!

Diese kann dann bei jedem weiteren Start geladen und verwendet werden (das Laden wird wohl schneller gehen als das Berechnen aller Werte)

Selbst das Laden von einer SSD würde wahrscheinlich länger dauern, als das Berechnen bei Programmstart


@Heinz Mendax
Warum solltest du "Millionen Variable und Arrays" brauchen? DIM Farbwerte.f($FFFFFF,6) und gut ist! Belegt 940MB Ram. Der 1.Parameter ist der Index für deine Farbe, der 2. für den Farbwert 1-6.

[helpy]

DIM Farbwerte.f($FFFFFF,6) und gut ist! Belegt 940MB Ram.

Ich bekommen ein anderes Ergebnis!
Annähernd 920MByte werden belegt, wenn Du .d anstatt .f verwendest.
Bei Verwendung von .f sind es ca. 460MByte.

Mit einem Array von Strukturen braucht man noch eine Spur weniger Speicherplatz.
Knapp 400 MByte bei Verwendung einer Struktur mit .f Werten:

Code: Alles auswählen

Structure fWerte
  wert1.f
  wert2.f
  wert3.f
  wert4.f
  wert5.f
  wert6.f
EndStructure

MessageRequester("","CHECK memory usage of process")
Dim Farbwerte.fWerte($FFFFFF)
MessageRequester("","CHECK memory usage of process")

[man-in-black]

Ihr habt die "0" in der Rechnung übersehen

MFG
MIB

[7x7]

Ich bekommen ein anderes Ergebnis!
Annähernd 920MByte werden belegt, wenn Du .d anstatt .f verwendest.
Bei Verwendung von .f sind es ca. 460MByte.

Hast natürlich Recht: ".f" ist 4-Byte! In meinem 64-Bit-Schädel ist generell erstmal alles 8-Byte groß

DIM Farbwerte.f($FFFFFF,6) = ~470MB Speicherbedarf

Ihr habt die "0" in der Rechnung übersehen

Nein...haben wir nicht.

[grapy]

Also, da alle RGB Werte ja bekannt sind reicht es doch wenn ich alle Float Werte
hintereinander in eine Datei stecke.
Die hat dann übrigens cremige 384 Mbyte und ist im nu gespeichert sowie gelesen.

[helpy]

[quote="7x7"

Diese kann dann bei jedem weiteren Start geladen und verwendet werden (das Laden wird wohl schneller gehen als das Berechnen aller Werte)

Selbst das Laden von einer SSD würde wahrscheinlich länger dauern, als das Berechnen bei Programmstart[/quote]

Ich habe das mal bei mir getestet.
Das direkte Laden von Festplatte ist bei mir (keine SSD) um den Faktor 24 schneller!

LG,
guido