C_CAPSULE_START


OPP_INLINE int opp_factory_create_full(struct opp_factory*obuff
		, SYNC_UWORD16_T inc
		, SYNC_UWORD16_T obj_size
		, int token_offset
		, unsigned char property
		, opp_callback_t callback
	) {
	SYNC_ASSERT(obj_size < (1024<<1));
	SYNC_ASSERT(inc);
#ifdef SYNC_LOW_MEMORY
	SYNC_ASSERT(inc < 1024);
#else
	SYNC_ASSERT(inc < (1024<<3));
#endif

	if(obuff->sign == OPPF_INITIALIZED_INTERNAL) {
		SYNC_LOG(SYNC_ERROR, "obj is already initiated\n");
		SYNC_ASSERT(obuff->sign != OPPF_INITIALIZED_INTERNAL);
		return -1;
	}
	/* check possible leak capacity */
	if(inc >= 0x7FFF) {
		SYNC_LOG(SYNC_ERROR, "too big allocation\n");
		SYNC_ASSERT(inc < 0x7FFF);
		return -1;
	}
	/* pool size */
	const SYNC_UWORD16_T pool_size = inc;
	/* obj size */
	SYNC_UWORD16_T fixed_obj_size = obj_size + sizeof(struct opp_object);
	fixed_obj_size = OPP_NORMALIZE_SIZE(fixed_obj_size);
	/* bitstring size */
	unsigned long long bitstring_size = (inc+7) >> 3;
	bitstring_size = OPP_NORMALIZE_SIZE(bitstring_size);
	bitstring_size = bitstring_size*BITFIELD_SIZE;
	/* check possible leak */
	if(bitstring_size >=  0x7FFF) {
		SYNC_LOG(SYNC_ERROR, "too big allocation\n");
		SYNC_ASSERT(bitstring_size < 0x7FFF);
		return -1;
	}
	const unsigned long long memory_chunk_size = sizeof(struct opp_pool) + fixed_obj_size*pool_size + bitstring_size;
	/* check possible leak */
	if(0x7FFFFFFF < memory_chunk_size) {
		SYNC_LOG(SYNC_ERROR, "too big allocation\n");
		SYNC_ASSERT(0x7FFFFFFF > memory_chunk_size);
		return -1;
	}
#ifndef OBJ_MAX_BUFFER_SIZE
#define OBJ_MAX_BUFFER_SIZE (4096<<10)
#endif
	SYNC_ASSERT(obuff->memory_chunk_size < OBJ_MAX_BUFFER_SIZE);
	struct opp_factory template = {
Example #2
0
    void freceive_more_async(boost::asio::io_service & ios, aziomq::socket & socket,
                             const const_buf_vec & expected_bufs, int flags) {
        SYNC_LOG(__PRETTY_FUNCTION__);
         //create vector of raw bufs to fill from length of expected_bufs
        buf_vec_t buf_vec(std::distance(std::begin(expected_bufs),
                                        std::end(expected_bufs)));
        zero(buf_vec);

         //create azio buffer vector
        mutable_buf_vec bufs;
        init(bufs, buf_vec);

        auto it = std::begin(bufs);
        auto e = std::end(bufs);

        std::exception_ptr err;
        socket.async_receive_more(boost::asio::buffer(*it++),
                [&ios, &socket, &bufs, &it, e, &err, expected_bufs](const boost::system::error_code & ec,
                                                                   aziomq::socket::more_result mr) {
                    if (ec) {
                        err = std::make_exception_ptr(boost::system::system_error(ec));
                    } else {
                        for (; mr.second && it != e; ++it) {
                            mr = socket.receive_more(boost::asio::buffer(*it));
                            err = check_res(bufs, expected_bufs);
                        }
                    }
                    ios.stop();
                });
        ios.run();
        if (err != std::exception_ptr())
            std::rethrow_exception(err);
    }
Example #3
0
    void freceive_async(boost::asio::io_service & ios, aziomq::socket & socket,
                            const const_buf_vec & expected_bufs, int flags) {
        SYNC_LOG(__PRETTY_FUNCTION__);
         //create vector of raw bufs to fill from length of expected_bufs
        buf_vec_t buf_vec(std::distance(std::begin(expected_bufs),
                                        std::end(expected_bufs)));
        zero(buf_vec);

         //create azio buffer vector
        mutable_buf_vec bufs;
        init(bufs, buf_vec);

        std::exception_ptr err;
        socket.async_receive(bufs,
                [&ios, &bufs, &err, expected_bufs](const boost::system::error_code & ec, size_t bytes_transferred) {
                    if (ec) {
                        err = std::make_exception_ptr(boost::system::system_error(ec));
                    } else {
                        err = check_res(bufs, expected_bufs);
                    }
                    ios.stop();
                });
        ios.run();
        if (err != std::exception_ptr())
            std::rethrow_exception(err);
    }
Example #4
0
 void fsend_async(boost::asio::io_service & ios, aziomq::socket & socket, const const_buf_vec & bufs, int flags) {
     SYNC_LOG(__PRETTY_FUNCTION__);
     std::exception_ptr err;
     socket.async_send(bufs,
             [&ios,&err](const boost::system::error_code & ec, size_t bytes_transferred) {
                 if (ec)
                     err = std::make_exception_ptr(boost::system::system_error(ec));
                 ios.stop();
             });
     ios.run();
     if (err != std::exception_ptr())
         std::rethrow_exception(err);
 }
OPP_INLINE static SYNC_UWORD8_T opp_alloc4_count_slots(SYNC_UWORD16_T size, const SYNC_UWORD16_T obj_size, const SYNC_UWORD16_T pool_size) {
	SYNC_UWORD8_T slot_count = 1;
	if(!size) /* the default size is one slot */
		return 1;
	size += sizeof(struct opp_object); /* we need to add object header */
	OPP_NORMALIZE_SIZE(size); /* we need to convert the size into a chunk size */
	/* TODO optimize the following line */
	slot_count = size / obj_size + ((size % obj_size)?1:0); /* find the number of slot_count needed */

	/* number of slot_count must be smaller than bit per string */
	if(slot_count > BIT_PER_STRING) {
		SYNC_LOG(SYNC_ERROR, "Alloc failed:solt %d cannot fit in %d-bit header for request size %d\n", slot_count, BIT_PER_STRING, size);
		return 0;
	}
	/* number of slot_count must be smaller than object pool size */
	if(slot_count > pool_size) {
		SYNC_LOG(SYNC_ERROR, "Alloc failed:Cannot fit solts %d in pool of %d\n", slot_count, pool_size);
		return 0;
	}
	/* apply some invariant testing */
	SYNC_ASSERT(slot_count != 0);
	SYNC_ASSERT(slot_count <= BIT_PER_STRING && slot_count <= pool_size);
	return slot_count;
}
Example #6
0
    void freceive_sync(boost::asio::io_service &, aziomq::socket & socket,
                            const const_buf_vec & expected_bufs, int flags) {
        SYNC_LOG(__PRETTY_FUNCTION__);
        // create vector of raw bufs to fill from length of expected_bufs
        buf_vec_t buf_vec(std::distance(std::begin(expected_bufs),
                                        std::end(expected_bufs)));
        zero(buf_vec);

        // create azio buffer vector
        mutable_buf_vec bufs;
        init(bufs, buf_vec);

        socket.receive(bufs, flags);
        auto e = check_res(bufs, expected_bufs);
        if (e != std::exception_ptr())
            std::rethrow_exception(e);
    }
C_CAPSULE_START

OPP_INLINE struct opp_pool*opp_factory_create_pool_donot_use(struct opp_factory*obuff, struct opp_pool*addpoint, void*nofreememory) {
	// allocate a block of memory
	struct opp_pool*pool = (struct opp_pool*)nofreememory;
	opp_factory_profiler_checkleak();
	if(!pool && !(pool = (struct opp_pool*)profiler_replace_malloc(obuff->memory_chunk_size))) {
		SYNC_LOG(SYNC_ERROR, "Out of memory\n");
		return NULL;
	}

	if(!obuff->pools) {
		obuff->pools = pool;
		pool->idx = 0;
		pool->next = NULL;
	} else {
		SYNC_ASSERT(addpoint);
		// insert the pool in appropriate place
		pool->next = addpoint->next;
		addpoint->next = pool;
		pool->idx = addpoint->idx+1;
	}
	if(pool->idx > 64) {
		opp_watchdog_report(WATCHDOG_ALERT, "pool->idx > 64");
	}

	obuff->pool_count++;
	opp_factory_profiler_checkleak();

	SYNC_UWORD8_T*ret = (SYNC_UWORD8_T*)(pool+1);
	/* clear bitstring */
	memset(ret, 0, obuff->bitstring_size);
	// setup pool
	pool->bitstring = (BITSTRING_TYPE*)ret;
#ifdef OPP_HAS_RECYCLING
	pool->recycled = NULL;
#endif
	pool->head = ret + (obuff->bitstring_size);
	pool->end = ret + obuff->memory_chunk_size - sizeof(struct opp_pool);
	pool->flags = nofreememory?0:OPP_POOL_FREEABLE;
	CHECK_POOL(pool);
	return pool;
}
Example #8
0
    void freceive_more_sync(boost::asio::io_service &, aziomq::socket & socket,
                            const const_buf_vec & expected_bufs, int flags) {
        SYNC_LOG(__PRETTY_FUNCTION__);
        // create vector of raw bufs to fill from length of expected_bufs
        buf_vec_t buf_vec(std::distance(std::begin(expected_bufs),
                                        std::end(expected_bufs)));
        zero(buf_vec);

        // create azio buffer vector
        mutable_buf_vec bufs;
        init(bufs, buf_vec);

        aziomq::socket::more_result mr = std::make_pair(0, true);
        for (auto it = std::begin(bufs), e = std::end(bufs); mr.second && it != e; ++it) {
            mr = socket.receive_more(boost::asio::buffer(*it), flags);
        }

        auto e = check_res(bufs, expected_bufs);
        if (e != std::exception_ptr())
            std::rethrow_exception(e);
    }
Example #9
0
 void fsend_sync(boost::asio::io_service &, aziomq::socket & socket, const const_buf_vec & bufs, int flags) {
     SYNC_LOG(__PRETTY_FUNCTION__);
     socket.send(bufs, flags);
 }