Mercurial > cgi-bin > hgwebdir.cgi > VMS > C_Libraries > Queue_impl

annotate PrivateQueue.c @ 17:1e93e5dbeda1

find changesets by author, revision, files, or words in the commit message
Build process fix
author Merten Sach <msach@mailbox.tu-berlin.de>
date Wed, 22 Jun 2011 16:55:10 +0200
parents 8fd77f9430f0
children 7c9e00ff1bf4
rev   line source
Me@0 1 /*
Me@8 2 * Copyright 2009 OpenSourceStewardshipFoundation.org
Me@0 3 * Licensed under GNU General Public License version 2
Me@0 4 *
Me@0 5 * Author: seanhalle@yahoo.com
Me@0 6 */
Me@0 7
Me@0 8
Me@0 9 #include <stdio.h>
Me@0 10 #include <string.h>
Me@0 11 #include <errno.h>
Me@0 12 #include <stdlib.h>
Me@0 13
Me@0 14 #include "PrivateQueue.h"
msach@17 15 #include "../vmalloc.h"
Me@0 16
Me@0 17
Me@0 18
Me@0 19 //===========================================================================
Me@0 20
Me@0 21 /*This kind of queue is private to a single core at a time -- has no
Me@0 22 * synchronizations
Me@0 23 */
Me@0 24
Me@16 25 PrivQueueStruc* makeVMSPrivQ()
Me@0 26 {
msach@17 27 PrivQueueStruc *retQ;
msach@17 28 retQ = VMS__malloc( sizeof( PrivQueueStruc ) );
msach@17 29 retQ->startOfData = (void*)VMS__malloc( 1024 * sizeof(void *) );
Me@14 30 memset( retQ->startOfData, 0, 1024 );
Me@14 31
Me@0 32 retQ->extractPos = &(retQ->startOfData[0]); //side by side == empty
Me@0 33 retQ->insertPos = &(retQ->startOfData[1]); // so start pos's have to be
Me@0 34 retQ->endOfData = &(retQ->startOfData[1023]);
Me@0 35
Me@0 36 return retQ;
Me@0 37 }
Me@0 38
Me@2 39
Me@2 40 void
Me@2 41 enlargePrivQ( PrivQueueStruc *Q )
Me@0 42 { int oldSize, newSize;
Me@0 43 void **oldStartOfData;
Me@0 44
Me@0 45 oldSize = Q->endOfData - Q->startOfData;
Me@0 46 newSize = 2 * oldSize;
Me@6 47 oldStartOfData = Q->startOfData;
Me@9 48 Q->startOfData = VMS__malloc( newSize * sizeof(void *) );
Me@0 49 memcpy(Q->startOfData, oldStartOfData, oldSize * sizeof(void *));
Me@9 50 VMS__free(oldStartOfData);
Me@0 51
Me@0 52 Q->extractPos = &(Q->startOfData[0]); //side by side == empty
Me@0 53 Q->insertPos = &(Q->startOfData[1]); // so start pos's have to be
Me@0 54 Q->endOfData = &(Q->startOfData[newSize - 1]);
Me@0 55 }
Me@0 56
Me@0 57
Me@0 58 /*Returns NULL when queue is empty
Me@0 59 */
Me@0 60 void* readPrivQ( PrivQueueStruc* Q )
Me@0 61 { void *out = 0;
Me@2 62 void **startOfData = Q->startOfData;
Me@2 63 void **endOfData = Q->endOfData;
Me@0 64
Me@2 65 void **insertPos = Q->insertPos;
Me@2 66 void **extractPos = Q->extractPos;
Me@0 67
Me@6 68 //if not empty -- (extract is just below insert when empty)
Me@0 69 if( insertPos - extractPos != 1 &&
Me@0 70 !(extractPos == endOfData && insertPos == startOfData))
Me@0 71 { //move before read
Me@0 72 if( extractPos == endOfData ) //write new pos exactly once, correctly
Me@0 73 { Q->extractPos = startOfData; //can't overrun then fix it 'cause
Me@0 74 } // other thread might read bad pos
Me@0 75 else
Me@0 76 { Q->extractPos++;
Me@0 77 }
Me@0 78 out = *(Q->extractPos);
Me@0 79 return out;
Me@0 80 }
Me@0 81 //Q is empty
Me@0 82 return NULL;
Me@0 83 }
Me@0 84
Me@11 85 int32
Me@11 86 numInPrivQ( PrivQueueStruc *Q )
Me@11 87 { int32 size, numIn;
Me@11 88
Me@11 89 if( Q->insertPos < Q->extractPos )
Me@11 90 { //insert has wrapped around so numIn is:
Me@11 91 // insertPos + size - extractPos -- Consider, is empty when
Me@11 92 // extractPos = endOfData and insert = start -- correctly get zero
Me@11 93 size = Q->endOfData - Q->startOfData;
Me@11 94 numIn = Q->insertPos + size - Q->extractPos;
Me@11 95 }
Me@11 96 else
Me@11 97 {
Me@11 98 numIn = Q->insertPos - Q->extractPos -1;//-1 bec empty @ side-by-side
Me@11 99 }
Me@11 100 return numIn;
Me@11 101 }
Me@11 102
Me@2 103
Me@2 104 /*Expands the queue size automatically when it's full
Me@2 105 */
Me@2 106 void
Me@6 107 writePrivQ( void * in, PrivQueueStruc* Q )
Me@2 108 {
Me@2 109 void **startOfData = Q->startOfData;
Me@2 110 void **endOfData = Q->endOfData;
Me@2 111
Me@2 112 void **insertPos = Q->insertPos;
Me@2 113 void **extractPos = Q->extractPos;
Me@2 114
Me@2 115 tryAgain:
Me@6 116 //Full? (insert is just below extract when full)
Me@2 117 if( extractPos - insertPos != 1 &&
Me@2 118 !(insertPos == endOfData && extractPos == startOfData))
Me@2 119 { *(Q->insertPos) = in; //insert before move
Me@2 120 if( insertPos == endOfData ) //write new pos exactly once, correctly
Me@2 121 { Q->insertPos = startOfData;
Me@2 122 }
Me@2 123 else
Me@2 124 { Q->insertPos++;
Me@2 125 }
Me@2 126 return;
Me@2 127 }
Me@2 128 //Q is full
Me@2 129 enlargePrivQ( Q );
Me@2 130 goto tryAgain;
Me@2 131 }
Me@2 132
Me@2 133
Me@0 134 /*Returns false when the queue was full.
Me@0 135 * have option of calling make_larger_PrivQ to make more room, then try again
Me@0 136 */
Me@6 137 int writeIfSpacePrivQ( void * in, PrivQueueStruc* Q )
Me@0 138 {
Me@2 139 void **startOfData = Q->startOfData;
Me@2 140 void **endOfData = Q->endOfData;
Me@2 141
Me@2 142 void **insertPos = Q->insertPos;
Me@2 143 void **extractPos = Q->extractPos;
Me@0 144
Me@0 145 if( extractPos - insertPos != 1 &&
Me@0 146 !(insertPos == endOfData && extractPos == startOfData))
Me@2 147 { *(Q->insertPos) = in; //insert before move
Me@0 148 if( insertPos == endOfData ) //write new pos exactly once, correctly
Me@0 149 { Q->insertPos = startOfData;
Me@0 150 }
Me@0 151 else
Me@0 152 { Q->insertPos++;
Me@0 153 }
Me@0 154 return TRUE;
Me@0 155 }
Me@0 156 //Q is full
Me@0 157 return FALSE;
Me@0 158 }
Me@9 159
SeanHalle@12 160 /*Treats queue as a stack -- no matter contents, if read done right after
SeanHalle@12 161 * a push, then the pushed item is what comes out.
SeanHalle@12 162 * Expands the queue size automatically when it's full.
SeanHalle@12 163 */
SeanHalle@12 164 void
SeanHalle@12 165 pushPrivQ( void * in, PrivQueueStruc* Q )
SeanHalle@12 166 {
SeanHalle@12 167 void **startOfData = Q->startOfData;
SeanHalle@12 168 void **endOfData = Q->endOfData;
SeanHalle@12 169
SeanHalle@12 170 void **insertPos = Q->insertPos;
SeanHalle@12 171 void **extractPos = Q->extractPos;
SeanHalle@12 172
SeanHalle@12 173 tryAgain:
SeanHalle@12 174 //Full? (insert is just below extract when full)
SeanHalle@12 175 if( extractPos - insertPos != 1 &&
SeanHalle@12 176 !(insertPos == endOfData && extractPos == startOfData))
SeanHalle@12 177 { //insert -- but go backwards, inserting at read position then
SeanHalle@12 178 // move read pos backwards
SeanHalle@12 179 *(Q->extractPos) = in;
SeanHalle@12 180 if( extractPos == startOfData ) //write new pos exactly once, correctly
SeanHalle@12 181 { Q->extractPos = endOfData; //can't overrun then fix it 'cause
SeanHalle@12 182 } // other thread might read bad pos
SeanHalle@12 183 else
SeanHalle@12 184 { Q->extractPos--;
SeanHalle@12 185 }
SeanHalle@12 186 return;
SeanHalle@12 187 }
SeanHalle@12 188 //Q is full
SeanHalle@12 189 enlargePrivQ( Q );
SeanHalle@12 190 goto tryAgain;
SeanHalle@12 191 }
SeanHalle@12 192
Me@9 193 void
Me@9 194 freePrivQ( PrivQueueStruc *Q )
Me@9 195 {
Me@9 196 VMS__free( Q->startOfData );
Me@9 197 VMS__free( Q );
Me@9 198 }