Does my C code work?

Details: Your parallel sort $($psort$)$ will take two command$-$line arguments.

The input file will consist of records; within each record is a key. The key is the first four bytes of the record. The records are fixed$-$size, and are each $100$ bytes $($which includes the key$).$

As part of testing of your program, you should generate your own test inputs of different size to cover various corner cases, and large input sizes.

A successful sort will read all the records into memory from the input file, sort them, and then write them out to the output file.

You also have to force writes to disk by calling fsync$()$ on the output file before finishing.

You can assume that this is a one$-$pass sort, i$.$e$.,$ the data can fit into memory. You do not have to implement a multi$-$pass sort.

Your code should compile $($and should be compiled$)$ with the following flags: $-$Wall $-$Werror $-$pthread $-$O$.$ The last one is important: it turns on the optimizer! In fact, for fun, try timing your code with and without $-$O and marvel at the difference.

Your code will first be measured for correctness, ensuring that it sorts input files correctly.

If you pass the correctness tests, your code will be tested for performance

Code:

#include

#include

#include

#include

#include

#include

#include

#include

#define RECORD$\_$SIZE $100$

typedef struct $\{$

char data$[$RECORD$\_$SIZE$]$;

$\}$ Record;

typedef struct $\{$

Record $*$records;

int start;

int end;

$\}$ ThreadArg;

void merge$($Record $*$records$,$ int start, int mid, int end$)\{$

int n$1=$ mid $-$ start $+1$;

int n$2=$ end $-$ mid;

Record $*$left $=($Record $*)$malloc$($n$1*$ sizeof$($Record$))$;

Record $*$right $=($Record $*)$malloc$($n$2*$ sizeof$($Record$))$;

for $($int i $=0$; i $<$ n$1$; i$++)$

left$[$i$]=$ records$[$start $+$ i$]$;

for $($int i $=0$; i $<$ n$2$; i$++)$

right$[$i$]=$ records$[$mid $+1+$ i$]$;

int i $=0,$ j $=0,$ k $=$ start;

while $($i $<$ n$1$ && j $<$ n$2)\{$

if $($memcmp$($left$[$i$].$data, right$[$j$].$data, $4)<=0)\{$

records$[$k$++]=$ left$[$i$++]$;

$\}$ else $\{$

records$[$k$++]=$ right$[$j$++]$;

$\}$

$\}$

while $($i $<$ n$1)\{$

records$[$k$++]=$ left$[$i$++]$;

$\}$

while $($j $<$ n$2)\{$

records$[$k$++]=$ right$[$j$++]$;

$\}$

free$($left$)$;

free$($right$)$;

$\}$

void $*$thread$\_$sort$($void $*$arg$)\{$

ThreadArg $*$threadArg $=($ThreadArg $*)$arg;

Record $*$records $=$ threadArg$->$records;

int start $=$ threadArg$->$start;

int end $=$ threadArg$->$end;

if $($start $<$ end$)\{$

int mid $=$ start $+($end $-$ start$)/2$;

ThreadArg arg$1=\{$records$,$ start, mid$\}$;

ThreadArg arg$2=\{$records$,$ mid $+1,$ end$\}$;

pthread$\_$t tid$1,$ tid$2$;

pthread$\_$create$($&tid$1,$ NULL, thread$\_$sort, &arg$1)$;

pthread$\_$create$($&tid$2,$ NULL, thread$\_$sort, &arg$2)$;

pthread$\_$join$($tid$1,$ NULL$)$;

pthread$\_$join$($tid$2,$ NULL$)$;

merge$($records$,$ start, mid, end$)$;

$\}$

return NULL;

$\}$

int main$($int argc, char $*$argv$[])\{$

if $($argc $!=3)\{$

fprintf$($stderr$,$ "Usage: $\%$s

$",$ argv$[0])$;

exit$($EXIT$\_$FAILURE$)$;

$\}$

const char $*$input$\_$file $=$ argv$[1]$;

const char $*$output$\_$file $=$ argv$[2]$;

int fd $=$ open$($input$\_$file, O$\_$RDONLY$)$;

if $($fd $<0)\{$

perror$("$open input file"$)$;

exit$($EXIT$\_$FAILURE$)$;

$\}$

struct stat sb;

if $($fstat$($fd$,$ &sb$)<0)\{$

perror$("$fstat$")$;

exit$($EXIT$\_$FAILURE$)$;

$\}$

size$\_$t file$\_$size $=$ sb$.$st$\_$size;

size$\_$t num$\_$records $=$ file$\_$size $/$ RECORD$\_$SIZE;

Record $*$records $=$ mmap$($NULL$,$ file$\_$size, PROT$\_$READ $|$ PROT$\_$WRITE, MAP$\_$PRIVATE, fd$,0)$;

if $($records $==$ MAP$\_$FAILED$)\{$

perror$("$mmap$")$;

exit$($EXIT$\_$FAILURE$)$;

$\}$

close$($fd$)$;

ThreadArg arg $=\{$records$,0,$ num$\_$records $-1\}$;

pthread$\_$t tid;

pthread$\_$create$($&tid, NULL, thread$\_$sort, &arg$)$;

pthread$\_$join$($tid$,$ NULL$)$;

int ofd $=$ open$($output$\_$file, O$\_$WRONLY $|$ O$\_$CREAT $|$ O$\_$TRUNC, S$\_$IRUSR $|$ S$\_$IWUSR$)$;

if $($ofd $<0)\{$

perror$("$open output file"$)$;

exit$($EXIT$\_$FAILURE$)$;

$\}$

if $($write$($ofd$,$ records, file$\_$size$)!=$ file$\_$size$)\{$

perror$("$write$")$;

exit$($EXIT$\_$FAILURE$)$;

$\}$

if $($fsync$($ofd$)<0)\{$

perror$("$fsync$")$;

exit$($EXIT$\_$FAILURE$)$;

$\}$

close$($ofd$)$;

munmap$($records$,$ file$\_$size$)$;

return $0$;

$\}$