Question

I am getting the Segmentation fault error on the Ubuntu machine but not on macOS.

Any help would be appreciated.

/**** main.c ****/

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <pthread.h>
#include <string.h>
#define WORD_LEN 6
#define TOP 10

char * delim = "\"\'.“”‘’?:;-,—*($%)! \t\n\x0A\r";

struct Word {
    char word[30];
    int freq;
};

int threadCount;
int fileDescriptor;
int fileSize;
off_t chunk;
struct Word* wordArray;
int arrIndex = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; // initialize mutex lock

/* add words to the struct array; mutex is used for protecting shared resources */
void addWord(char* token) {
    for (int i=0; i<=arrIndex; i++) {
        if (i == arrIndex) {
            pthread_mutex_lock(&lock);      // mutex is locked here
            strcpy(wordArray[i].word, token);
            wordArray[i].freq++;
            arrIndex++;
            //wordArray = realloc(wordArray, sizeof((int*)wordArray)); // dynamically allocate memory for the array
            pthread_mutex_unlock(&lock);    // mutex is unlocked here
            break;
        } else if (strcmp(wordArray[i].word, token) == 0) {  // compare string in a case insensitive fashion
            pthread_mutex_lock(&lock);      // mutex is locked here
            wordArray[i].freq++;
            pthread_mutex_unlock(&lock);    // mutex is unlocked here
            break;
        }
    }
}

/* read words from each chunk of the file */
void* readWord(void* arg) {
    char* buf = (char*) malloc(chunk);  // allocate memory for buffer

    /* use pread to read from a file descriptor at a given offset */
    off_t* bufEnd = (off_t*) arg;
    off_t bufStart = *bufEnd - chunk;
    pread(fileDescriptor, buf, chunk, bufStart);

    /* splitting string by using strtok_r to maintain context between successive calls
     * that parse the same string */
    char* token;
    while ((token = strtok_r(buf, delim, &buf))) {
        if (strlen(token) >= WORD_LEN)
            addWord(token);
    }
    pthread_exit(0);
}

void swap(struct Word* a, struct Word* b) {
    struct Word tmp = *a;
    *a = *b;
    *b = tmp;
}
int partition (struct Word arr[], int low, int high) {
    int pivot = arr[high].freq;    // pivot
    int i = (low - 1);  // index of smaller element

    for (int j = low; j <= high- 1; j++) {
        // if current element is smaller than the pivot
        if (arr[j].freq < pivot) {
            i++;    // increment index of smaller element
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);
}
void quickSort(struct Word arr[], int low, int high) {
    if (low < high) {
        /* pi is partitioning index, arr[p] is now
           at right place */
        int pi = partition(arr, low, high);

        /* Separately sort elements before
           partition and after partition */
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

int main (int argc, char *argv[])
    {
    //***TO DO***  Look at arguments, open file, divide by threads
    //             Allocate and Initialize and storage structures
    wordArray = malloc(1 * sizeof(struct Word));    // allocate memory for struct array

    if (!argv[1] || !argv[2]) {     // make sure the user enter the file name and thread number
        printf("\nfile name or thread number is missing!\n\n");
        exit(EXIT_FAILURE);
    }
    fileDescriptor = open(argv[1], O_RDONLY);   // open the file for reading
    threadCount = atoi(argv[2]);    // convert the thread number to an int
    fileSize = lseek(fileDescriptor, 0, SEEK_END);  // get the file size
    chunk = (fileSize / threadCount);   // divide the file by the number of threads
    /* get the position for each thread */
    int* bufPosition[threadCount];
    for (int i=0; i < threadCount; i++)
        bufPosition[i] = (int *) ((i + 1) * chunk);

    //**************************************************************
    // DO NOT CHANGE THIS BLOCK
    //Time stamp start
    struct timespec startTime;
    struct timespec endTime;

    clock_gettime(CLOCK_REALTIME, &startTime);
    //**************************************************************
    // *** TO DO ***  start your thread processing
    //                wait for the threads to finish
    pthread_t threadID[threadCount];    // array of threads
    /* create threads */
    for (int i=0; i < threadCount; i++)
        pthread_create(&threadID[i], NULL, readWord, &bufPosition[i]);
    /* wait for each thread to terminate */
    for (int i=0; i < threadCount; i++)
        pthread_join(threadID[i], NULL);

    // ***TO DO *** Process TOP 10 and display
    printf("\nWord Frequency Count on %s with %d threads\n", argv[1], atoi(argv[2]));
    printf("Printing top %d words %d characters or more.\n", TOP, WORD_LEN);

    /* sort the array in descending order and then print the top 10 */
    quickSort(wordArray, 0, arrIndex);
    int n = 1;
    for (int j = arrIndex; j > arrIndex - TOP; j--) {
        printf("Number %d is %s with a count of %d\n", n, wordArray[j].word, wordArray[j].freq );
        n++;
    }

    //**************************************************************
    // DO NOT CHANGE THIS BLOCK
    //Clock output
    clock_gettime(CLOCK_REALTIME, &endTime);
    time_t sec = endTime.tv_sec - startTime.tv_sec;
    long n_sec = endTime.tv_nsec - startTime.tv_nsec;
    if (endTime.tv_nsec < startTime.tv_nsec)
        {
        --sec;
        n_sec = n_sec + 1000000000L;
        }

    printf("Total Time was %ld.%09ld seconds\n", sec, n_sec);
    //**************************************************************

    // ***TO DO *** cleanup
    close(fileDescriptor);
    free(wordArray);
    }

(base) Evans-MBP-2:word-blast evancai$ ./main WarAndPeace. txt 4 Word Frequency Count on WarAndPeace. txt with 4 threads Printing top 10 words 6 characters or more. Number 1 is Pierre with a count of 1963 Number 2 is Prince with a count of 1577 Number 3 is Natasha with a count of 1212 Number 4 is Andrew with a count of 1143 Number 5 is himself with a count of 1018 Number 6 is French with a count of 881 Number 7 is before with a count of 779 Number 8 is Rostov with a count of 776 Number 9 is thought with a count of 766 Number 10 is CHAPTER with a count of 730 Total Time was 0.851825000 seconds (base) Evans-MBP-2:word-blast evancais

Answer 1

Segmentation fault (core dumped) errors occur when you are trying to access a memory location that does not belong to you or you are trying to do something wrong with the memory. It occurs when you try to write into the read only memory.It also occurs when we try to access the freed or released memory location.It is reported several times during stack overflows and during the improper use of scanf.It can also be attributed to defrencing Null pointer.

Example 1 When a string is being modified

#include<stdio.h>

int main (void)

{

// writing to a read only memory initiate segmentation fault

char *s = "Virat Kohli is the greatest of all indian batsman" ;

*s= "H" ;

}

it will give segmentation error

Example 2 When scanf is used improperly

#include<stdio.h>

int main()

{

int p=10;

scanf("%d",p) ; //this is a bug!! we can't pass values here , it has to be an address

return 0;

}

It should be written as scanf("%d", &ch);

It will again on compilation will give segmentation error

Example 3 out of Array

#include<stdio.h>

int main()

{

int arr [10];

arr[11]=100; //this is illegal core dump!!

return 0;

}

Array has limit 0f 10 and we are assigning a value in 11 element so it will get error stack smash detector core dump

Example 4 Out of stack

In this we are showing recursion function

// this is recursion and it will cause stack overflow

#include<stdio.h>

int main (void)

{

main();

return 0;

}

main is inside int main , it is known as recursion it will keep on looping and looping and will cause segmentation.

There is nothing wrong with the program but due to excessive looping segmentation error occurs.

you can try these things out and eliminate any such instance from your program if it is encountered by you at any point of time.