1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:

procedure TMainform.Button1Click(Sender: TObject);
var
  Schleife   : cardinal;  // int64 nicht möglich
  ZahlByte   : byte;
  Zahl       : cardinal;
  FS         : TFileStream;
  DatenBlock : array [0..124999] of byte; // 125.000 Bytes = 1 Mio. Bits bzw. Zahlen
begin
  FS := TFileStream.Create('L:\Primzahlen.PRIM', fmOpenReadWrite or fmCreate);
  try
    for Schleife := 0 to 124999 do
      DatenBlock[Schleife] := $55;
    for Schleife := 1 to 80000 do   // = 10 Mrd. Bytes große Datei (= 80 Mrd. Bits / Zahlen)
      FS.Write(DatenBlock, SizeOf(DatenBlock));
    FS.Position := 0;                    // zurück zum Anfang
    FS.Read(ZahlByte, SizeOf(ZahlByte)); // nur ein Byte lesen
    ZahlByte := ZahlByte xor $03;        // 1 keine Primzahl, 2 = Primzahl
    FS.Position := 0;         // Durch das Lesen wurde der Zeiger verschoben.
    FS.Write(ZahlByte, SizeOf(ZahlByte));
      // Kleiner Test, um das Endian-Problem zu verdeutlichen.
    FS.Position := 10;        // Durch das Schreiben wurde der Zeiger verschoben.
                              // Wird hier willkürlich auf 10 (= 11. Byte) gesetzt.
    Zahl := $12345678;        // Im Hex-Editor mal die Bytes ansehen. (siehe Endian)
    FS.Write(Zahl, SizeOf(Zahl));
  finally
    FS.Free;
  end;
end;					

1:
2:
3:
4:

For Schleife:=1 to 80000 do
 begin
 //
 end;					

1:
2:
3:
4:
5:
6:

Schleife := 1;
while Schleife <= 80000 do
 begin
 //
 inc(Schleife);
 end;					

1:

for Schleife := 1 to 80000 do   // = 10 Mrd. Bytes große Datei (= 80 Mrd. Bits / Zahlen)					

1:

 DatenBlock[Schleife] := $55;					

1:
2:

For Schleife:=1 to High(DatenBlock) do
 FS.WriteBuffer(DatenBlock[Schleife], SizeOf(DatenBlock[Schleife]); //WriteBuffer oder Write?					

1:
2:
3:
4:
5:
6:
7:
8:
9:

{Type TSavedDataBlocks = record
 Pfad: String; //fester Pfad + '\' + IntToStr(BlockNr);
 Anzahl: Cardinal
end;
var GespBloecke: Array of TSavedDataBlocks;}

setlength(DatenBlock, Gesp[BlockNr].Anzahl);
For Schleife:=High(DatenBlock) downto 1 do // von hinten nach vorn, wie du oben sagtest ist richtig oder?
  FS.ReadBuffer(DatenBlock[Schleife], SizeOf(DatenBlock[Schleife])); //ReadBuffer oder Read ? ich kenns mit Buffer...					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:

program LOP;

// Lots Of Primes
// mr_emre_d
// @ entwickler-ecke.de

{$APPTYPE CONSOLE}

uses
  Windows;

type
  TByteBoolean = record
    Value: Byte;
    function GetBit(const Index: Integer): Boolean;
    procedure SetBit(const Index: Integer; const Bit: Boolean);
  end;

  TByteBooleanArray = Array of TByteBoolean;

{$REGION 'TByteBoolean'}

function TByteBoolean.GetBit(const Index: Integer): Boolean;
begin
  Result := Value and (1 shl Index) <> 0;
end;

procedure TByteBoolean.SetBit(const Index: Integer; const Bit: Boolean);
begin
  if Bit then
    Value := Value or (1 shl Index)
  else
    Value := Value and not (1 shl Index);
end;

{$ENDREGION}

(*
** ExtendedSieveOfEratosthenes calculates primenumber in a given range
** the range is specified by [StartingNumber, Primes.Len*2]
** Primes.Len * 2 because the Primes Array only contains odd numbers (since even numbers cant be prime)
*)
procedure ExtendedSieveOfEratosthenes(const FromOffset: UInt64; var Primes: TByteBooleanArray);
var
  ToOffset  : UInt64;
  candidate : UInt64;
  multiples : UInt64;
  index     : Integer;
begin
  candidate := 3;
  ToOffset := FromOffset + Length(Primes) shl 4;
  while candidate < ToOffset do
  begin
    // fast-iterate to the beginning of the sieve
    if candidate < FromOffset then
    begin
      multiples := candidate * Round(FromOffset/candidate);
      if multiples < FromOffset then
        inc(multiples, candidate);
    end else
      multiples := candidate shl 1;

    // if the first multiple is already out of bounds we can stop sieving
    if multiples > ToOffset then break;

    // sieve
    while multiples <= ToOffset do
    begin
      // odd numbers only
      if multiples and 1 = 1 then
      begin
        index := (multiples - FromOffset) shr 1;
        Primes[index shr 3].SetBit(index mod 8, false);
      end;
      inc(multiples, candidate);
    end;

    // ignore even numbers
    inc(candidate, 2);
  end;
end;

var
  Primes: TByteBooleanArray;
  iteration: Integer;
  p, q: Integer;
  From: UInt64;
  Tick: DWORD;
  Duration: DWORD;
  Til: UInt64;
  PrimeCount: UInt64;
  ptr: PDWord;
  cnt4: DWord;

begin
  SetLength(Primes, 1024*1024 shr 4);
  From := 3;
  Til := 1000000000;
  Til := Til * 12;
  iteration := 0;
  PrimeCount := 0;
  Duration := GetTickCount;
  cnt4 := Length(Primes) div 4;
  while From < Til do
  begin
    inc(iteration);
    ptr := @Primes[0];
    for p := 0 to cnt4 do
    begin
      ptr^ := $FFFFFFFF;
      inc(ptr);
    end;
    ExtendedSieveOfEratosthenes(From, Primes);
    for p := 0 to High(Primes) do
      for q := 0 to 7 do
        if Primes[p].GetBit(q) then
        begin
          if (From + (p*8 + q)*2) < Til then
            inc(PrimeCount);
//          Writeln(PrimeCount, '. ', (From + (p*8+q)*2));
        end;
//    Readln;
    if iteration mod 100 = 0 then
      Write('[Iteration #', iteration, '] calculated primes [', From, ', ', From + Length(Primes) shl 1,
        '] (time: ', (GetTickCount-Duration)/1000:6:2, ')'#13);
    inc(From, Length(Primes) shl 4);
  end;
  Duration := GetTickCount - Duration;

  Writeln('Finished, took me ', Duration/1000:8:2, ' seconds... ');
  Writeln('Found ', PrimeCount, ' primes');
  Readln;
end.					

1:
2:
3:
4:

Hoechste Primzahl 510529
Siebe ab                  0
Gesiebt bis     22801929150      1.000.006.971
real  1m1.053s