cnt lowers with array & pthreads

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <stdint.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <ctype.h>
#include <string.h>

static int N_THREADS;
static int *arrCnt;

off_t getFileSize(const char fpath[]) {
    struct stat statBuf;
    if (stat(fpath, &statBuf)) {
        perror("stat");
        exit(1);
    }
    return statBuf.st_size;
}

typedef struct {
    int thread_id;
    int start;
    int end;
    char *file_content;
} ThreadData;

void *routine(void *arg) {
    ThreadData *data = (ThreadData *)arg;
    int cnt = 0;

    for (int i = data->start; i < data->end; i++) {
        if (islower(data->file_content[i])) {
            cnt++;
        }
    }

    arrCnt[data->thread_id] = cnt;
    return NULL;
}

void *zalloc(int nmemb, int size) {
    void *p = calloc(nmemb, size);
    if (!p) {
        perror("calloc");
        exit(1);
    }
    return p;
}

int main(int argc, char *argv[]) {
    if (argc != 3) {
        fprintf(stderr, "Usage: %s <file_name> <num_threads>\n", argv[0]);
        exit(1);
    }

    N_THREADS = atoi(argv[2]);
    if (N_THREADS <= 0) {
        fprintf(stderr, "Number of threads must be greater than 0.\n");
        exit(1);
    }

    // Get file size
    int fsize = getFileSize(argv[1]);
    if (fsize == 0) {
        fprintf(stderr, "File is empty.\n");
        exit(1);
    }

    // Open the file
    int fd = open(argv[1], O_RDONLY);
    if (fd == -1) {
        perror("open");
        exit(1);
    }

    // Read the entire file into memory
    char *file_content = zalloc(fsize + 1, sizeof(char));
    if (read(fd, file_content, fsize) != fsize) {
        perror("read");
        free(file_content);
        close(fd);
        exit(1);
    }
    file_content[fsize] = '\0'; // Null-terminate the file content

    close(fd);

    // Allocate memory for thread results
    arrCnt = zalloc(N_THREADS, sizeof(*arrCnt));

    // Create threads
    pthread_t threads[N_THREADS];
    ThreadData thread_data[N_THREADS];

    int bytesPerTh = fsize / N_THREADS;
    for (int i = 0; i < N_THREADS; i++) {
        thread_data[i].thread_id = i;
        thread_data[i].start = i * bytesPerTh;
        thread_data[i].end = (i == N_THREADS - 1) ? fsize : (i + 1) * bytesPerTh;
        thread_data[i].file_content = file_content;

        if (pthread_create(&threads[i], NULL, routine, &thread_data[i]) != 0) {
            perror("pthread_create");
            free(file_content);
            free(arrCnt);
            exit(1);
        }
    }

    // Join threads
    for (int i = 0; i < N_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }

    // Sum up the results
    int total_lowercase = 0;
    for (int i = 0; i < N_THREADS; i++) {
        total_lowercase += arrCnt[i];
    }

    printf("Total lowercase letters: %d\n", total_lowercase);

    // Clean up
    free(file_content);
    free(arrCnt);

    return 0;
}