void * ring_poolmanager_allocate ( RingState *pRingState,size_t size ) { void *pMemory ; pMemory = NULL ; /* If No memory - Create new block */ if ( (pRingState->vPoolManager.pCurrentItem == NULL) && (pRingState->vPoolManager.pBlockStart == NULL) && (pRingState->lStartPoolManager) ) { ring_poolmanager_newblock(pRingState); } /* Get Item from the Pool Manager */ if ( pRingState->vPoolManager.pCurrentItem != NULL ) { pMemory = pRingState->vPoolManager.pCurrentItem ; pRingState->vPoolManager.pCurrentItem = pRingState->vPoolManager.pCurrentItem->pNext ; } /* If no free items, Allocate new item */ else { pMemory = ring_malloc(size); /* Check Memory */ if ( pMemory == NULL ) { printf( RING_OOM ) ; exit(0); } } #if RING_TRACKALLOCATIONS pRingState->vPoolManager.nSmallAllocCount++ ; #endif return pMemory ; }
static PyObject* init(PyObject *self, PyObject *args) { ring = ring_malloc(RING_SIZE); init_serialize(ring); return Py_BuildValue(""); }
RING_API void * ring_state_malloc ( void *pState,size_t size ) { #if RING_USEPOOLMANAGER if ( pState != NULL ) { #if RING_TRACKALLOCATIONS ((RingState *) pState)->vPoolManager.nAllocCount++ ; #endif if ( size <= RING_POOLMANAGER_ITEMSIZE ) { return ring_poolmanager_allocate((RingState *) pState,size) ; } } #endif return ring_malloc(size) ; }
/** Register a function to be called after N_TICKS have elapsed from now. * PERIOIDIC_P is nonzero if the timer function should be called repeatedly, * every time that much time has elapsed. * FN is the function to be called and DATA can be anything at all, passed to * the handler. */ void sim_time_register (int n_ticks, int periodic_p, time_handler_t fn, void *data) { unsigned int ring = ring_later (n_ticks); struct time_handler *elem = ring_malloc (); if (!elem) simlog (SLC_DEBUG, "can't alloc ring"); if (n_ticks > RING_COUNT) simlog (SLC_DEBUG, "can't schedule timer that far out"); elem->next = time_handler_ring[ring]; elem->periodicity = periodic_p ? n_ticks : 0; elem->fn = fn; elem->data = data; time_handler_ring[ring] = elem; }
void test_ring() { int size; unsigned char *buf = malloc(sizeof(unsigned char) * BUF_SIZE); Ring *ring = ring_malloc(BUF_SIZE); RingReader *reader = reader_malloc(ring); size = reader_read(reader, buf); assert(0 == size); printf("one write and one read\n"); ring_write(ring, "11", 2); size = reader_read(reader, buf); assert(2 == size); assert(0 == memcmp(buf, "11", 2)); printf("two writes and one read due to overflow\n"); ring_write(ring, "22", 2); ring_write(ring, "33", 2); size = reader_read(reader, buf); assert(-1 == size); size = reader_read(reader, buf); assert(2 == size); assert(0 == memcmp(buf, "33", 2)); printf("two small writes and two reads\n"); ring_write(ring, "4", 1); ring_write(ring, "5", 1); size = reader_read(reader, buf); assert(1 == size); assert(0 == memcmp(buf, "4", 1)); size = reader_read(reader, buf); assert(1 == size); assert(0 == memcmp(buf, "5", 1)); printf("fill once again\n"); ring_write(ring, "123456", 6); size = reader_read(reader, buf); assert(6 == size); assert(0 == memcmp(buf, "123456", 6)); ring_free(ring); }
void test_raw() { Ring *ring = ring_malloc(BUF_SIZE); unsigned char *buf = malloc(sizeof(unsigned char) * BUF_SIZE); unsigned char *reference = malloc(sizeof(unsigned char) * BUF_SIZE); int i; for (i=0; i < BUF_SIZE; i++) { reference[i] = i; } // raw write entire buffer and verify ring_raw_write(ring, 0, reference, BUF_SIZE); ring_raw_read(ring, buf, 0, BUF_SIZE); assert(0 == memcmp(reference, buf, BUF_SIZE)); // raw write entire buffer from middle and verify ring_raw_write(ring, BUF_SIZE / 2, reference, BUF_SIZE); ring_raw_read(ring, buf, BUF_SIZE / 2, BUF_SIZE); assert(0 == memcmp(reference, buf, BUF_SIZE)); ring_free(ring); }