include 'd:\fasm\include\win32ax.inc'

.data
        FileTitle db 'myfile.txt',0
        hFile dd ?
        nSize dd ?
        lpBytesRead dd ?
        lpBuffer rb 8192

        count dd 0
        letter db 'x',0
        MessageBoxCaption db 'repetitons:',0

.code
        main:

                invoke CreateFile, FileTitle, GENERIC_READ, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0 ; open the file to read
                mov [hFile], eax ;Save the file's handle to hFile
                invoke GetFileSize, [hFile], 0 ; Determine the file size

                ;---------------
                ;if entire file needs to be displayed:

                ; mov [nSize] , eax ; Save the file size given by EAX
                ; invoke MessageBox, NULL, addr lpBuffer , addr MessageBoxCaption, MB_OK
                ; invoke CloseHandle, [hFile]
                ; invoke ExitProcess,0

                ;---------------

                .while 1 ;or another exit parameter
                          invoke ReadFile, [hFile], lpBuffer, 1 , lpBytesRead, 0 ;read one byte from file
                          .if (lpBuffer = letter)
                              add counter, 1
                          .endif

                          .if(????) 
                          ;end while-loop condition? maybe 'GetOverlappedResult [hFile], lpBuffer, 1 , lpBytesRead, 0' would do the magic but I cannot seem to make it work
                                jmp endofwhile
                .endw

                endofwhile:
                invoke CloseHandle, [hFile] ;   Handle should be close after the file has been read

                add counter, 48 ; is it needed to dispaly an int as ASCII?

                invoke MessageBox, NULL, addr counter , addr MessageBoxCaption, MB_OK
                invoke ExitProcess,0
        .end main  
    

text text text    

add counter, 48

When operand is a data in memory, the address of that data (also any numerical expression, but it may contain registers) should be enclosed in square brackets or preceded by ptr operator. For example instruction mov eax,3 will put the immediate value 3 into the EAX register, instruction mov eax,[7] will put the 32-bit value from the address 7 into EAX and the instruction mov byte [7],3 will put the immediate value 3 into the byte at address 7, it can also be written as mov byte ptr 7,3. To specify which segment register should be used for addressing, segment register name followed by a colon should be put just before the address value (inside the square brackets or after the ptr operator).

format PE CONSOLE
entry main
include 'win32a.inc'

section '.code' code readable writeable executable
        proc main
                cinvoke fopen, fileName, fileMode
                mov [fp], eax
                test eax, eax
                jz .end
                
                .loop:
                cinvoke fgetc, [fp]
                cmp eax, -1 ;EOF
                je .eof
                cmp al, [letter]
                jne .loop
                inc [count]
                jmp .loop
                
                .eof:
                movzx eax, [letter]
                cinvoke printf, fmt, eax, fileName, [count]
                cinvoke fclose, [fp]
                cinvoke getch
                xor eax, eax
                .end:
                ret
        endp

section '.data' data readable writeable
        fp dd ?
        count dd ?
        fileName db 'file.txt', 0
        fileMode db 'r', 0
        letter db 't'
        fmt db 'Number of `%c` in %s: %i', 13, 10, 0

section '.idata' import data readable writeable
        library msvcrt, 'msvcrt.dll'
        
        import msvcrt,\
                fopen, 'fopen',\
                fclose, 'fclose',\
                fgetc, 'fgetc',\
                printf, 'printf',\
                getch, '_getch' ;for pause
    

По русски понимаеш ?

;
; COUNT BYTES IN FILE
;
format  PE GUI 4.0
entry   start
stack   4000h, 4000h

    include 'Win32W.Inc'

; ---------------------------------------------------------------------------
section '.data' data readable writeable

    glb_FilePath  db 'C:\Temp\MyFile.txt',0    ; <-- put your test file name in here
    glb_BufMsg    rb 80
    glb_FmtMsg    db 'There are %d characters found in file.',0
    glb_Title     db 'Counting Characters...',0

; ---------------------------------------------------------------------------
section '.code' code readable executable

; ---------------------------------------------------------------------------
virtual at 0
loc1:
    .Buffer       db ?  ; Loaded ANSI character from file
    .FindMe       db ?  ; Character to look for
    .Padding      rb 2  ; For alignment (stack must be aligned to DWORD)
    .CharsLoaded  dd ?  ; Can be 0 (if file ended) or 1 (next character loaded)
    .CountChars   dd ?  ; Character counter
    .size = $
end virtual

align 16
TFile_CountChars:
; ---------------------------------------------------------------------------
; INPUT:
;   ESI = ANSI file name
;    AL = character code to count
; OUTPUT:
;   EAX = count of characters in file
; ---------------------------------------------------------------------------
    push      ebx esi edi ebp
    ;
    ; Save AL for now (because CreateFile will destroy it)
    ;
    mov       edi, eax
    ;
    ; Open file for reading
    ;
    invoke    CreateFileA, esi, GENERIC_READ, 0, 0, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, 0
    cmp       eax, INVALID_HANDLE_VALUE
    je        .no_file
    ;
    ; File opened OK
    ;
    mov       ebx, eax     ; store file handle into EBX
    ;
    ; At this point some local variables needed, so the
    ; small structure 'loc1' is allocated on stack and
    ; EBP is pointed to this structure.
    ;
    sub       esp, loc1.size
    mov       ebp, esp
    ;
    ; Two buffers are needed for ReadFile:
    ; - buffer into which character is loaded (ESI)
    ; - buffer into which  # of bytes is stored (EDI)
    ;
    mov       esi, ebp
    lea       eax, [ebp + loc1.CharsLoaded]
    xchg      eax, edi
    mov       [ebp + loc1.FindMe], al
    and       [ebp + loc1.CountChars], 0   ; Set COUNTER=0
    ;
    ; In the loop read characters from file (1-by-1)
    ;
.read_char:
    invoke    ReadFile, ebx, esi, 1, edi, 0
    ;
    ; See if we got the character
    ;
    mov       ecx, [edi]
    jecxz     .no_more_bytes
    ;
    ; See if the character at ESI is the one we need
    ;
    mov       al, [esi]
    ;
    ; ECX = 1 (if AL is matching the ANSI code parameter) or 0 (if no match)
    ;
    xor       ecx, ecx
    cmp       al, [ebp + loc1.FindMe]
    sete      cl
    ;
    ; Add ECX to the counter
    ;
    add       [ebp + loc1.CountChars], ecx
    jmp       .read_char

.no_more_bytes:
    invoke    CloseHandle, ebx                ; Close file
    mov       eax, [ebp + loc1.CountChars]    ; EAX = return value
    add       esp, loc1.size                  ; 'Forget' local variables
    jmp       .done

.no_file:
    xor       eax, eax      ; Return zero

.done:
    pop       ebp edi esi ebx
    ret

; ---------------------------------------------------------------------------
; PROGRAM ENTRY POINT
; ---------------------------------------------------------------------------
align 16
start:
    ;
    ; A small test
    ;
    mov       al, 't'
    mov       esi, glb_FilePath
    call      TFile_CountChars
    ;
    ; Show the counter in a message box
    ;
    mov       edi, glb_BufMsg
    cinvoke   wsprintfA, edi, glb_FmtMsg, eax
    invoke    MessageBoxA, 0, edi, glb_Title, MB_ICONINFORMATION
    ;
    ; Quit
    ;
    invoke    ExitProcess, 0

; ---------------------------------------------------------------------------
section '.idata' import data readable writeable

    library kernel32,'KERNEL32.DLL',user32,'USER32.DLL',gdi32,'GDI32.DLL'

    include 'API\Kernel32.Inc'
    include 'API\User32.Inc'
    include 'API\Gdi32.Inc'
    

ReadFile(file.h, p, file.size, tmp.rw, 0)    

function count.file.c, file, c
  locals n
  try load.text file
  get n=text.count.c r0, c
  flush
endf n    

It's best to read the entire file once into memory then iterate through it. Reading individual bytes is strongly discouraged, it could take seconds to load 4MB worth of files (4,194,304 disk reads versus one. Optimized C/C++ compilers will use memory I/O).

I don't think you would read the entire 16GB file at once

4MB (Megabytes, 4,194,304 bytes) was the example I used. Millions of physical disk reads (only need one) = Extreme hard drive thrashing.

a user would have to go to extreme lengths to force it to perform poorly

Quote:

a user would have to go to extreme lengths to force it to perform poorly

On my PCs (laptop+ITX), it takes about 5 seconds to load 4MB worth of images using ReadFile for individual bytes. But if I read the entire file once then process in memory, it will load in the blink of an eye. I guess my old version of Win7 does not have internal caching.

And here's my implementation of "Open file, read by char and count a specific char" (using Microsoft C Runtime DLL [msvcrt])

Code:

format PE CONSOLE
entry main
include 'win32a.inc'

section '.code' code readable writeable executable
        proc main
                cinvoke fopen, fileName, fileMode
                mov [fp], eax
                test eax, eax
                jz .end
                
                .loop:
                cinvoke fgetc, [fp]
                cmp eax, -1 ;EOF
                je .eof
                cmp al, [letter]
                jne .loop
                inc [count]
                jmp .loop
                
                .eof:
                movzx eax, [letter]
                cinvoke printf, fmt, eax, fileName, [count]
                cinvoke fclose, [fp]
                cinvoke getch
                xor eax, eax
                .end:
                ret
        endp

section '.data' data readable writeable
        fp dd ?
        count dd ?
        fileName db 'file.txt', 0
        fileMode db 'r', 0
        letter db 't'
        fmt db 'Number of `%c` in %s: %i', 13, 10, 0

section '.idata' import data readable writeable
        library msvcrt, 'msvcrt.dll'
        
        import msvcrt,\
                fopen, 'fopen',\
                fclose, 'fclose',\
                fgetc, 'fgetc',\
                printf, 'printf',\
                getch, '_getch' ;for pause
    

For almost all users Windows will have caching enabled .... I find Windows to be very robust and fast when reading and writing files, and a user would have to go to extreme lengths to force it to perform poorly. ....

Imo it is misleading to suggest that Windows' disk caching is provided as a "feature". Without it Windows'performance would be even more canine

macro forever {
 local ..start, ..next, ..end
 ?START equ ..start
 ?NEXT equ ..next
 ?END equ ..end
 ?START:
}

macro endfv {
  ?NEXT:
  jmp ?START
 ?END:
 restore ?START, ?NEXT, ?END
}    

for (;;) {} /* nasty hacks! */
while (1) {}    

how about searching a word instead of a char?

long    nMatches=0, foundMatches, ofsFile=-1;
char    c;
char    word[8];

strcpy (word, "text");  // Loking for "text" in file
foundMatches = strlen (word);

while (1)
{
        c = LoadByteFromFile();
        if (no bytes left in file) break;
        //
        // 'c' is a next character from file
        //
        ++ofsFile;
        if (c == word [nMatches])
        {
                ++nMatches;
                if (nMatches == foundMatches)
                {
                        ofsFile -= foundMatches-1;
                        //
                        // Word has been found at offset 'ofsFile' in file!
                        //
                }
        }
        else
        {
                if ((nMatches != 0) && (c == word [0]))
                {
                        nMatches=1;
                        continue;
                }
                nMatches=0;
        }
}