Annotation of libaitsched/example/test.c, revision 1.9.2.6

1.2       misho       1: #include <stdio.h>
1.7       misho       2: #include <stdlib.h>
                      3: #include <string.h>
1.2       misho       4: #include <unistd.h>
                      5: #include <fcntl.h>
1.5       misho       6: #include <signal.h>
1.2       misho       7: #include <sys/types.h>
                      8: #include <sys/stat.h>
                      9: #include <sys/socket.h>
                     10: #include <netinet/in.h>
1.7       misho      11: #include "../inc/config.h"
1.2       misho      12: #include <aitsched.h>
                     13: 
                     14: intptr_t Kill;
1.7       misho      15: #ifdef AIO_SUPPORT
                     16: struct iovec iv[3], wiv[3], riv[3];
                     17: #endif
1.2       misho      18: 
                     19: void *event(sched_task_t *arg)
                     20: {
                     21:        printf("Event::\n");
1.9.2.1   misho      22:        taskExit(arg, NULL);
1.2       misho      23: }
                     24: 
1.8       misho      25: void *regular(sched_task_t *arg)
1.2       misho      26: {
1.8       misho      27:        printf("Task::\n");
1.9.2.1   misho      28:        taskExit(arg, NULL);
1.2       misho      29: }
                     30: 
                     31: void *timer(sched_task_t *arg)
                     32: {
1.6       misho      33:        printf("Timer %p sec::\n", TASK_ARG(arg));
1.9.2.1   misho      34:        taskExit(arg, NULL);
1.2       misho      35: }
                     36: 
                     37: void *r(sched_task_t *arg)
                     38: {
1.9       misho      39:        printf("read:: %d bytes wait\n", TASK_RET(arg));
1.2       misho      40:        Kill++;
1.9.2.1   misho      41:        taskExit(arg, NULL);
1.2       misho      42: }
                     43: 
                     44: void *w(sched_task_t *arg)
                     45: {
1.9       misho      46:        printf("write:: %d bytes wait\n", TASK_RET(arg));
1.9.2.1   misho      47:        taskExit(arg, NULL);
1.2       misho      48: }
                     49: 
                     50: void *once(sched_task_t *arg)
                     51: {
                     52:        printf("once::\n");
1.9.2.1   misho      53:        taskExit(arg, NULL);
1.2       misho      54: }
                     55: 
1.7       misho      56: #ifdef AIO_SUPPORT
                     57: void *aioread(sched_task_t *arg);
                     58: void *aiowrite(sched_task_t *arg)
                     59: {
                     60:        char *ole = malloc(BUFSIZ);
                     61: 
                     62:        printf("AIO write[%d]:: %d bytes\n%p\n", TASK_FD(arg), (int) TASK_DATLEN(arg), 
                     63:                        TASK_DATA(arg));
                     64:        free(TASK_DATA(arg));
                     65: 
                     66:        memset(ole, 0, BUFSIZ);
                     67:        schedAIORead(TASK_ROOT(arg), aioread, NULL, TASK_FD(arg), ole, BUFSIZ - 1, -1);
1.9.2.1   misho      68:        taskExit(arg, NULL);
1.7       misho      69: }
                     70: 
                     71: void *aioread(sched_task_t *arg)
                     72: {
                     73:        char *ole = malloc(BUFSIZ);
                     74:        int len;
                     75: 
                     76:        printf("AIO read[%d]:: %d bytes\n%s\n-------\n", TASK_FD(arg), (int) TASK_DATLEN(arg), 
                     77:                        (char*) TASK_DATA(arg));
                     78: 
                     79:        if (TASK_ARG(arg)) {
                     80:                len = strlcpy(ole, "++++++BAHURA OR CULTURE .... A CULTURE OR BAHURA :-)\n", BUFSIZ);
                     81:                printf("sched Write len=%d %p\n", len, ole);
                     82:                schedAIOWrite(TASK_ROOT(arg), aiowrite, TASK_ARG(arg), TASK_FD(arg), ole,  len, -1);
                     83:                                
                     84:        }
                     85:        free(TASK_DATA(arg));
1.9.2.1   misho      86:        taskExit(arg, NULL);
1.7       misho      87: }
                     88: 
                     89: void *aiobulkread(sched_task_t *arg)
                     90: {
                     91:        struct iovec *iv = TASK_DATA(arg);
                     92:        register int i;
                     93: 
                     94:        printf("aioBULKread::\n");
                     95:        for (i = 0; i < 3; i++) {
                     96:                printf("%d) rlen[%d]=%s\n---\n", i, iv[i].iov_len, (char*) iv[i].iov_base);
                     97:                free(iv[i].iov_base);
                     98:        }
                     99: 
1.9.2.1   misho     100:        taskExit(arg, NULL);
1.7       misho     101: }
                    102: 
                    103: void *aiobulkwrite(sched_task_t *arg)
                    104: {
                    105:        struct iovec *iv = TASK_DATA(arg);
                    106:        register int i;
                    107: 
                    108:        printf("aioBULKwrite::\n");
                    109:        for (i = 0; i < 3; i++) {
                    110:                printf("%d) wlen=%d\n", i, iv[i].iov_len);
                    111:                free(iv[i].iov_base);
                    112:        }
                    113: 
1.9.2.1   misho     114:        taskExit(arg, NULL);
1.7       misho     115: }
                    116: #endif
                    117: 
1.9       misho     118: void *thr(sched_task_t *arg)
                    119: {
1.9.2.4   misho     120:        printf("tid (%lx):: %s\n", TASK_VAL(arg), __func__);
1.9       misho     121:        taskExit(arg, 42);
                    122: }
                    123: 
1.9.2.2   misho     124: void *thr4kill(sched_task_t *arg)
                    125: {
1.9.2.4   misho     126:        char blah[BUFSIZ];
                    127: 
                    128:        printf("tid (%lx):: %s\n", TASK_VAL(arg), __func__);
                    129: 
                    130:        read(0, blah, sizeof blah);
                    131:        printf("never see!!! (%lx):: %s (%d == %d)\n", TASK_VAL(arg), (char*) TASK_ARG(arg), TASK_TYPE(arg), taskTHREAD);
1.9.2.2   misho     132:        taskExit(arg, 0);
                    133: }
                    134: 
1.5       misho     135: void sig(int s)
                    136: {
                    137:        switch (s) {
                    138:                case SIGTERM:
                    139:                        Kill++;
                    140:                        break;
                    141:        }
                    142: }
                    143: 
1.2       misho     144: int
                    145: main(int argc, char **argv)
                    146: {
                    147:        sched_root_task_t *root;
1.7       misho     148:        int f, fd;
1.2       misho     149:        struct sockaddr_in sin;
1.5       misho     150:        struct timespec ts = { 20, 0 };
                    151: //     struct timespec p = { 0, 10000000 };
                    152:        struct sigaction sa;
1.9.2.2   misho     153:        sched_task_t *t;
1.7       misho     154: #ifdef AIO_SUPPORT
                    155:        char *ole = malloc(BUFSIZ);
                    156:        register int i;
                    157: #endif
1.5       misho     158: 
                    159:        sa.sa_handler = sig;
                    160:        sigemptyset(&sa.sa_mask);
                    161:        sigaction(SIGTERM, &sa, NULL);
1.2       misho     162: 
                    163:        f = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
                    164:        if (f == -1)
                    165:                return 1;
                    166:        sin.sin_len = sizeof sin;
                    167:        sin.sin_family = AF_INET;
                    168:        sin.sin_port = htons(2345);
                    169:        sin.sin_addr.s_addr = INADDR_ANY;
                    170:        if (bind(f, (struct sockaddr*) &sin, sizeof sin) == -1)
                    171:                return 1;
                    172: 
1.7       misho     173:        fd = open("test_aio.dat", O_CREAT | O_RDWR, 0644);
                    174:        if (fd == -1)
                    175:                return 1;
                    176:        printf("fd=%d\n", fd);
                    177: 
1.2       misho     178:        root = schedBegin();
                    179:        if (!root) {
                    180:                printf("Error:: #%d - %s\n", sched_GetErrno(), sched_GetError());
                    181:                return 1;
                    182:        }
                    183: 
1.6       misho     184:        if (!schedTimer(root, timer, (void*) (intptr_t) ts.tv_sec, ts, NULL, 0)) {
1.5       misho     185:                printf("Error:: #%d - %s\n", sched_GetErrno(), sched_GetError());
                    186:                return 4;
                    187:        } else
                    188:                ts.tv_sec = 15;
1.6       misho     189:        if (!schedTimer(root, timer, (void*) (intptr_t) ts.tv_sec, ts, NULL, 0)) {
1.5       misho     190:                printf("Error:: #%d - %s\n", sched_GetErrno(), sched_GetError());
                    191:                return 4;
                    192:        } else
                    193:                ts.tv_sec = 10;
                    194: 
1.4       misho     195:        if (!schedEvent(root, event, "piuk", 1234, NULL, 0)) {
1.2       misho     196:                printf("Error:: #%d - %s\n", sched_GetErrno(), sched_GetError());
                    197:                return 2;
                    198:        }
                    199: 
1.8       misho     200:        if (!schedTask(root, regular, "piuk", 1111, NULL, 0)) {
1.2       misho     201:                printf("Error:: #%d - %s\n", sched_GetErrno(), sched_GetError());
                    202:                return 3;
                    203:        }
                    204: 
1.6       misho     205:        if (!schedTimer(root, timer, (void*) (intptr_t) ts.tv_sec, ts, NULL, 0)) {
1.2       misho     206:                printf("Error:: #%d - %s\n", sched_GetErrno(), sched_GetError());
                    207:                return 4;
                    208:        }
                    209: 
1.4       misho     210:        if (!schedRead(root, r, "rrr", f, NULL, 0)) {
1.2       misho     211:                printf("Error:: #%d - %s\n", sched_GetErrno(), sched_GetError());
                    212:                return 5;
                    213:        }
                    214: 
1.4       misho     215:        if (!schedWrite(root, w, "www", f, NULL, 0)) {
1.2       misho     216:                printf("Error:: #%d - %s\n", sched_GetErrno(), sched_GetError());
                    217:                return 6;
                    218:        }
                    219: 
1.9.2.4   misho     220:        if (!(t = schedThread(root, thr4kill, "0aaaa", 0, NULL, 0))) {
1.9       misho     221:                printf("Error:: #%d - %s\n", sched_GetErrno(), sched_GetError());
                    222:                return 7;
                    223:        }
1.9.2.4   misho     224:        if (!schedThread(root, thr, "mdaaaa this is thread task", 0, NULL, 0)) {
1.9.2.2   misho     225:                printf("Error:: #%d - %s\n", sched_GetErrno(), sched_GetError());
                    226:                return 7;
                    227:        }
1.9       misho     228:        if (!schedThread(root, thr, "mdaaaa this is thread task -detached", 42, NULL, 0)) {
                    229:                printf("Error:: #%d - %s\n", sched_GetErrno(), sched_GetError());
                    230:                return 7;
                    231:        }
                    232:        if (!schedThread(root, thr, "mdaaaa this is thread task -j", 0, NULL, 0)) {
                    233:                printf("Error:: #%d - %s\n", sched_GetErrno(), sched_GetError());
                    234:                return 7;
                    235:        }
1.9.2.4   misho     236:        printf("try to cancel tid = %lx\n", TASK_VAL(t));
1.9.2.3   misho     237:        schedCancel(t);
1.9.2.4   misho     238:        if (!schedThread(root, thr, "mdaaaa this is thread task -j2", 0, NULL, 0)) {
                    239:                printf("Error:: #%d - %s\n", sched_GetErrno(), sched_GetError());
                    240:                return 7;
                    241:        }
1.9.2.6 ! misho     242:        if (!(t = schedThread(root, thr4kill, "0aaaa", 42, NULL, 0))) {
        !           243:                printf("Error:: #%d - %s\n", sched_GetErrno(), sched_GetError());
        !           244:                return 7;
        !           245:        }
        !           246:        if (!schedThread(root, thr, "mdaaaa this is thread task -j3", 0, NULL, 0)) {
        !           247:                printf("Error:: #%d - %s\n", sched_GetErrno(), sched_GetError());
        !           248:                return 7;
        !           249:        }
        !           250:        sleep(1);
        !           251:        schedCancel(t);
1.9       misho     252: 
1.7       misho     253: #ifdef AIO_SUPPORT
                    254:        memset(ole, 0, BUFSIZ);
                    255:        if (!schedAIORead(root, aioread, (void*) f, fd, ole, BUFSIZ - 1, 0))
                    256:                printf("Warning:: #%d - %s\n", sched_GetErrno(), sched_GetError());
                    257: 
                    258: 
                    259:        iv[0].iov_len = 5;
                    260:        iv[1].iov_len = 2;
                    261:        iv[2].iov_len = 50;
                    262:        for (i = 0; i < 3; i++)
                    263:                iv[i].iov_base = malloc(iv[i].iov_len);
                    264:        if (!schedLIORead(root, aiobulkread, NULL, fd, iv, 3, 0))
                    265:                printf("Warning:: #%d - %s\n", sched_GetErrno(), sched_GetError());
                    266:        fsync(fd);
                    267:        for (i = 0; i < 3; i++) {
                    268:                wiv[i].iov_len = 100;
                    269:                wiv[i].iov_base = malloc(wiv[i].iov_len);
                    270:        }
                    271:        strlcpy(wiv[0].iov_base, "12345678900000000000000000\n", wiv[0].iov_len);
                    272:        wiv[0].iov_len = strlen(wiv[0].iov_base) + 1;
                    273:        strlcpy(wiv[1].iov_base, "222222222222222222222222\n", wiv[1].iov_len);
                    274:        wiv[1].iov_len = strlen(wiv[1].iov_base) + 1;
                    275:        strlcpy(wiv[2].iov_base, "333\n", wiv[2].iov_len);
                    276:        wiv[2].iov_len = strlen(wiv[2].iov_base) + 1;
                    277:        if (!schedLIOWrite(root, aiobulkwrite, NULL, fd, wiv, 3, 0))
                    278:                printf("Warning:: #%d - %s\n", sched_GetErrno(), sched_GetError());
                    279: 
                    280:        for (i = 0; i < 3; i++) {
                    281:                riv[i].iov_len = 5;
                    282:                riv[i].iov_base = malloc(riv[i].iov_len + 1);
                    283:                memset(riv[i].iov_base, 0, riv[i].iov_len + 1);
                    284:        }
                    285:        if (!schedLIORead(root, aiobulkread, NULL, fd, riv, 3, 0))
                    286:                printf("Warning:: #%d - %s\n", sched_GetErrno(), sched_GetError());
                    287: #endif
                    288: 
1.4       misho     289:        schedCallOnce(root, once, "000000", 42, NULL, 0);
1.2       misho     290: 
1.5       misho     291: //     schedPolling(root, &p, NULL);
1.2       misho     292:        schedRun(root, &Kill);
                    293:        schedEnd(&root);
                    294: 
1.7       misho     295: #ifdef AIO_SUPPORT
                    296:        for (i = 0; i < 3; i++)
                    297:                free(iv[i].iov_base);
                    298: #endif
                    299: 
                    300:        close(fd);
1.2       misho     301:        close(f);
                    302:        return 0;
                    303: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>