Commit 78475c0c authored by Darko's avatar Darko

Initial commit.

parent d06333fb
*.pyc
dist/
*.egg-info/
*.o
*.so
test
mergesort
=========
Academic example of merge sort implementation in C.
Implementation includes one process version and parallel
implementation using limited fork()s and example python
bindings using ctypes.
Contents
========
ms.h, ms.c - merge sort implementation
main.c - sample test of using merge sort implementation with time measurement
pyms.py - sample python bindings using ctypes
test.py - sample test of using pyms
Compile shared library with
.. code:: bash
cc -c -Wall -Werror -fpic ms.c
cc -shared -o libms.so ms.o
and sample C program (set LD_LIBRARY_PATH before running it)
.. code:: bash
cc -Wall -o test ms.c main.c
#include "ms.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/types.h>
#include <errno.h>
struct timespec timespecdiff(struct timespec start, struct timespec end)
{
struct timespec temp;
if ((end.tv_nsec - start.tv_nsec) < 0) {
temp.tv_sec = end.tv_sec - start.tv_sec - 1;
temp.tv_nsec = 1000000000 + end.tv_nsec - start.tv_nsec;
} else {
temp.tv_sec = end.tv_sec - start.tv_sec;
temp.tv_nsec = end.tv_nsec - start.tv_nsec;
}
return temp;
}
void shuffle(int foo[], size_t len)
{
int i;
int x;
int t;
for (i = 0; i < len; ++i) {
x = random() % len;
t = foo[x];
foo[x] = foo[i];
foo[i] = t;
}
}
int check_arr(int foo[], size_t len)
{
int i;
for (i = 0; i < len; ++i) {
if (foo[i] != i) {
return 0;
}
}
return 1;
}
int main(int argc, char **argv)
{
int i;
int *foo;
int len;
struct timespec start, end;
struct timespec diff;
long diffms;
int x;
int forklimitsz;
len = 50000001;
forklimitsz = 3;
foo = (int *) malloc(sizeof(int *) * len);
if (foo == NULL) {
fprintf(stderr, "Not enough memory\n");
exit(1);
}
for (i = 0; i < len; ++i) {
foo[i] = i;
}
srandom(time(NULL));
printf("arr len: %d\n", len);
for (x = 0; x < 2; ++x) {
if (x == 0) {
printf("linear\n");
} else {
printf("parallel\n");
}
shuffle(foo, len);
if (len <= 100) {
printf("sorting arr: \n");
for (i = 0; i < len; ++i) {
printf(" %d", foo[i]);
}
printf("\n");
}
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start);
if (x == 0) {
mymergesort(foo, len);
} else {
if (mymergesortp(foo, len, forklimitsz) < 0) {
perror("mergesortp");
}
}
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end);
if (len <= 100) {
printf("sorted arr: \n");
for (i = 0; i < len; ++i) {
printf(" %d", foo[i]);
}
printf("\n");
}
if (check_arr(foo, len) == 0) {
printf("ERROR in sort\n");
} else {
printf("sort OK\n");
diff = timespecdiff(start, end);
diffms = diff.tv_sec * 1000 + diff.tv_nsec / 1000000;
printf("duration: %lds %ldns\n\t%ldms\n", diff.tv_sec, diff.tv_nsec, diffms);
}
}
free(foo);
return 0;
}
#include "ms.h"
void mymerge(int left[], size_t leftlen, int right[], size_t rightlen, int res[])
{
size_t i;
size_t j;
size_t k;
for (i = 0, j = 0, k = 0; i < leftlen && j < rightlen;) {
if (left[i] <= right[j]) {
res[k++] = left[i++];
} else {
res[k++] = right[j++];
}
}
for (; i < leftlen; ++i) {
res[k++] = left[i];
}
for (; j < rightlen; ++j) {
res[k++] = right[j];
}
}
void _mergesort(int arr[], size_t len, int res[])
{
size_t mid;
size_t leftlen;
size_t rightlen;
int foo;
if (len == 2) {
if (arr[1] < arr[0]) {
foo = arr[1];
arr[1] = arr[0];
arr[0] = foo;
}
return;
} else if (len < 2) {
return;
}
mid = (len - 1) / 2;
leftlen = mid + 1;
rightlen = len - mid - 1;
_mergesort(arr, leftlen, res);
_mergesort(&arr[mid + 1], rightlen, &res[mid + 1]);
mymerge(arr, leftlen, &arr[mid + 1], rightlen, res);
memcpy(arr, res, len * sizeof(int));
}
int mymergesort(int arr[], size_t len)
{
int *res = (int *)malloc(sizeof(int *) * len);
if (res == NULL) {
return -1;
}
_mergesort(arr, len, res);
free(res);
return 0;
}
int _mergesortp(int arr[], size_t len, int res[], int forklimitsz)
{
size_t mid;
size_t leftlen;
size_t rightlen;
int foo;
pid_t pid, wpid;
int status;
if (len == 2) {
if (arr[1] < arr[0]) {
foo = arr[1];
arr[1] = arr[0];
arr[0] = foo;
}
return 0;
} else if (len < 2) {
return 0;
}
mid = (len - 1) / 2;
leftlen = mid + 1;
rightlen = len - mid - 1;
if (len <= forklimitsz) {
_mergesort(arr, leftlen, res);
_mergesort(&arr[mid + 1], rightlen, &res[mid + 1]);
mymerge(arr, leftlen, &arr[mid + 1], rightlen, res);
memcpy(arr, res, len * sizeof(int));
return 0;
}
pid = fork();
if (pid < 0) {
return -1;
}
if (pid == 0) { /* child */
foo = _mergesortp(&arr[mid + 1], rightlen, &res[mid + 1], forklimitsz);
if (foo < 0) {
exit(1);
}
exit(0);
} else { /* parent */
foo = _mergesortp(arr, leftlen, res, forklimitsz);
if (foo < 0) {
return foo;
}
/* wait child and then merge */
if ((wpid = waitpid(pid, &status, 0)) != pid) {
return -1;
}
if (status != 0) {
return status;
}
mymerge(arr, leftlen, &arr[mid + 1], rightlen, res);
memcpy(arr, res, len * sizeof(int));
return 0;
}
}
int mymergesortp(int arr[], size_t len, int cnt)
{
int foo;
int forklimitsz;
size_t size = sizeof(int) * len;
int *arrp = mmap(0, size, PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_ANON, -1, 0);
if (arrp == MAP_FAILED) {
return -1;
}
int *resp = mmap(0, size, PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_ANON, -1, 0);
if (resp == MAP_FAILED) {
munmap(arrp, size);
return -1;
}
memcpy(arrp, arr, size);
forklimitsz = len / cnt;
foo = _mergesortp(arrp, len, resp, forklimitsz);
memcpy(arr, arrp, size);
munmap(arrp, size);
munmap(resp, size);
return foo;
}
#ifndef __MS_H__
#define __MS_H__ 1
#include <sys/types.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/mman.h>
#include <string.h>
#include <sys/wait.h>
void mymerge(int left[], size_t leftlen, int right[], size_t rightlen, int res[]);
int mymergesort(int arr[], size_t len);
int mymergesortp(int arr[], size_t len, int cnt);
#endif
import ctypes
import sys
if sys.platform.startswith('win'):
_mslib = ctypes.CDLL('libms.dll')
else:
_mslib = ctypes.CDLL('libms.so')
def mergesort(arr):
size = len(arr)
IntArr = ctypes.c_int * size
x = IntArr(*arr)
foo = _mslib.mymergesort(x, size)
del arr[:]
arr.extend(x)
return foo
def mergesortp(arr, cnt):
size = len(arr)
IntArr = ctypes.c_int * size
x = IntArr(*arr)
foo = _mslib.mymergesortp(x, size, cnt)
del arr[:]
arr.extend(x)
return foo
from __future__ import print_function
import pyms
import random
import time
len = 50000001
forkdiv = 3
print("len: {}".format(len))
foo = [x for x in range(len)]
random.shuffle(foo)
print("linear")
start = time.time()
ret = pyms.mergesort(foo)
end = time.time()
if ret < 0:
print("error: {}".format(ret));
else:
for i, e in enumerate(foo):
if i != e:
print("ERROR in sort")
break
else:
print("sort OK")
diff = end - start
print("duration: {}".format(diff))
random.shuffle(foo)
print("parallel")
start = time.time()
ret = pyms.mergesortp(foo, forkdiv)
end = time.time()
if ret < 0:
print("error: {}".format(ret));
else:
for i, e in enumerate(foo):
if i != e:
print("ERROR in sort")
break
else:
print("sort OK")
diff = end - start
print("duration: {}".format(diff))
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment