void resize(size_t size)
{
if(this->size() != size)
{
cl_mem_flags flags;
cl_int status = BASE::data().getInfo(CL_MEM_FLAGS, &flags);
CLSPARSE_V(status, "buffer get info flags");
BASE::data() = create_buffer(size, flags);
}
}
vector(clsparseControl control, size_t size, const value_type& value = value_type(),
cl_mem_flags flags = CL_MEM_READ_WRITE, cl_bool init = true) :
queue(control->queue)
{
BASE::data() = create_buffer(size, flags);
if (init)
{
cl_int status = fill(control, value);
CLSPARSE_V(status, "vector.fill");
}
}
int trios_buffer_queue_init(
trios_buffer_queue_t *bq,
uint32_t initial_size,
uint32_t max_size,
uint8_t create_on_fly,
NNTI_transport_t *trans_hdl,
NNTI_buf_ops_t op,
uint32_t buffer_size)
{
NNTI_result_t nnti_rc=NNTI_OK;
NNTI_buffer_t *buffer=NULL;
log_debug(bq_debug_level, "enter");
if (buffer_size <= 0) {
log_debug(bq_debug_level, "buffer_size <= 0 - queue not created");
return((int)nnti_rc);
}
nthread_lock_init(&bq->mutex);
if (nthread_lock(&bq->mutex)) log_warn(bq_debug_level, "failed to get thread lock");
bq->current_size=0;
bq->initial_size=initial_size;
bq->max_size=max_size;
bq->create_on_fly=create_on_fly;
bq->trans_hdl=trans_hdl;
bq->op=op;
bq->buffer_size=buffer_size;
for (uint32_t i=0;i<bq->initial_size;i++) {
log_debug(bq_debug_level, "creating queue buffer");
nnti_rc=create_buffer(
bq->trans_hdl,
bq->op,
bq->buffer_size,
&buffer);
if (nnti_rc==NNTI_OK) {
log_debug(bq_debug_level, "pushing queue buffer");
bq->queue.push_back(buffer);
bq->current_size++;
} else {
log_error(bq_debug_level, "failed creating queue buffer: %d", nnti_rc);
break;
}
}
nthread_unlock(&bq->mutex);
log_debug(bq_debug_level, "exit");
return((int)nnti_rc);
}
static void
drm_create_prime_buffer(struct wl_client *client,
struct wl_resource *resource,
uint32_t id, int fd,
int32_t width, int32_t height, uint32_t format,
int32_t offset0, int32_t stride0,
int32_t offset1, int32_t stride1,
int32_t offset2, int32_t stride2)
{
create_buffer(client, resource, id, 0, fd, width, height, format,
offset0, stride0, offset1, stride1, offset2, stride2);
close(fd);
}
void init_primitives(asset::Asset_manager& asset_manager) {
dashed_line_shader = std::make_unique<Shader_program>();
dashed_line_shader->
attach_shader(asset_manager.load<Shader>("vert_shader:dashed_line"_aid))
.attach_shader(asset_manager.load<Shader>("frag_shader:dashed_line"_aid))
.bind_all_attribute_locations(line_vertex_layout)
.build();
std::vector<Line_vertex> unit_line_data {
{0},
{1}
};
unit_line = std::make_unique<Object>(line_vertex_layout, create_buffer(unit_line_data));
}
void context_lua_t::lua_pushmessage(lua_State *L, message_t& message)
{
message_array_t *array = NULL;
switch (message_data_type(message)) {
case NIL:
lua_pushnil(L);
return;
case TBOOLEAN:
lua_pushboolean(L, message_bool(message));
return;
case USERDATA:
lua_pushlightuserdata(L, message_userdata(message));
return;
case NUMBER:
lua_pushnumber(L, message_number(message));
return;
case INTEGER:
lua_pushinteger(L, message_integer(message));
return;
case BUFFER:
create_buffer(L, message_buffer(message));
return;
case STRING:
lua_pushstring(L, message_string(message));
return;
case BSON:
if (message_bson(message)->extract) {
bson_decode(message_bson(message), L);
} else {
create_bson(message_bson(message), L);
}
return;
case TERROR:
lua_pushinteger(L, message_error(message));
return;
case ARRAY:
array = message_array(message);
if (array != NULL && array->m_count > 0) {
for (int32_t i = 0; i < array->m_count; ++i) { //extract them
lua_pushmessage(L, array->m_array[i]);
}
} else {
lua_pushnil(L);
}
return;
default:
lua_pushnil(L);
return;
}
}
/********************************** Main routine ************************************/
void main(){
root=(node*)malloc(sizeof(node));
root->next=NULL;
create_buffer();
// initialize board and the audio port
init_hardware();
/* initialize hardware interrupts */
init_HWI();
/* loop indefinitely, waiting for interrupts */
while(1)
{};
}
static void
drm_create_prime_buffer(struct wl_client *client,
struct wl_resource *resource,
uint32_t id, int fd,
int32_t width, int32_t height, uint32_t format,
int32_t offset0, int32_t stride0,
int32_t offset1, int32_t stride1,
int32_t offset2, int32_t stride2)
{
trace(TRACE_DRM,
"%"PRId32",%"PRId32" fmt:%"PRId32, width, height, format);
create_buffer(client, resource, id, 0, fd, width, height, format,
offset0, stride0, offset1, stride1, offset2, stride2);
}
int main(int argc, char *argv[])
{
char *args[3];
char *env[1];
char *target = (argc == 2) ? argv[1] : "/usr/local/bin/target6";
args[0] = target; args[1] = create_buffer(); args[2] = NULL;
env[0] = NULL;
if (0 > execve(target, args, env))
fprintf(stderr, "execve failed.\n");
return 0;
}
pixel_buffer from_linear_buffer(const char * lbuf, int x, int y) {
pixel_buffer pb;
pixel p = {0,0,0};
pb = create_buffer(x,y,p);
int i,j;
for(j = 0; j < y; j++) {
for(i = 0; i < x; i++) {
pb.buffer[y,x].r = lbuf[y*x*4+0];
pb.buffer[y,x].g = lbuf[y*x*4+1];
pb.buffer[y,x].b = lbuf[y*x*4+2];
//ignore alpha
}
}
return pb;
}
void insert_blocks(struct group *group, block **blocks, size_t count)
{
buffer *buffer = create_buffer();
for (size_t i = 0; i < count; ++i)
{
block *block = blocks[i];
push_ptrarray(group->data->blocks, block);
get_block_triangles(block, buffer);
append_triangles(group->data, buffer);
clear_buffer(buffer);
}
destroy_buffer(buffer);
}
bool binary_writer::next(void** data, int* size)
{
int rem_size = _current_buffer_length - _current_offset;
if (rem_size == 0)
{
create_buffer(_reserved_size_per_buffer);
rem_size = _current_buffer_length;
}
*size = rem_size;
*data = (void*)(_current_buffer + _current_offset);
_current_offset = _current_buffer_length;
_total_size += rem_size;
return true;
}
csa_sada<t_enc_vec, t_dens, t_inv_dens, t_sa_sample_strat, t_isa, t_alphabet_strat>::csa_sada(cache_config& config)
{
create_buffer();
if (!cache_file_exists(key_trait<alphabet_type::int_width>::KEY_BWT, config)) {
return;
}
int_vector_buffer<alphabet_type::int_width> bwt_buf(cache_file_name(key_trait<alphabet_type::int_width>::KEY_BWT,config));
size_type n = bwt_buf.size();
{
auto event = memory_monitor::event("construct csa-alpbabet");
alphabet_type tmp_alphabet(bwt_buf, n);
m_alphabet.swap(tmp_alphabet);
}
int_vector<> cnt_chr(sigma, 0, bits::hi(n)+1);
for (typename alphabet_type::sigma_type i=0; i < sigma; ++i) {
cnt_chr[i] = C[i];
}
// calculate psi
{
auto event = memory_monitor::event("construct PSI");
// TODO: move PSI construct into construct_PSI.hpp
int_vector<> psi(n, 0, bits::hi(n)+1);
for (size_type i=0; i < n; ++i) {
psi[ cnt_chr[ char2comp[bwt_buf[i]] ]++ ] = i;
}
std::string psi_file = cache_file_name(conf::KEY_PSI, config);
if (!store_to_cache(psi, conf::KEY_PSI, config)) {
return;
}
}
{
auto event = memory_monitor::event("encode PSI");
int_vector_buffer<> psi_buf(cache_file_name(conf::KEY_PSI, config));
t_enc_vec tmp_psi(psi_buf);
m_psi.swap(tmp_psi);
}
{
auto event = memory_monitor::event("sample SA");
sa_sample_type tmp_sa_sample(config);
m_sa_sample.swap(tmp_sa_sample);
}
{
auto event = memory_monitor::event("sample ISA");
isa_sample_type isa_s(config, &m_sa_sample);
util::swap_support(m_isa_sample, isa_s, &m_sa_sample, (const sa_sample_type*)nullptr);
}
}
struct socket_buffer_pool* socket_buffer_pool_create()
{
struct socket_buffer_pool* pool = (struct socket_buffer_pool*)malloc(sizeof(*pool));
pool->cap = DEFAULT_POOL_SIZE;
pool->head = 0;
pool->tail = 0;
pool->lock = 0;
pool->queue = (struct socket_buffer**)malloc(sizeof(struct socket_buffer*) * pool->cap);
InitializeCriticalSection(&pool->cs);
for (int i=0; i<DEFAULT_POOL_SIZE; ++i)
{
socket_buffer_pool_put(pool, create_buffer());
}
return pool;
}
widget
texmacs_input_widget (tree doc, tree style, url wname) {
doc= enrich_embedded_document (doc, style);
url base = get_master_buffer (get_current_buffer ());
tm_view curvw= concrete_view (get_current_view ());
url name = embedded_name (wname);
if (contains (name, get_all_buffers ())) set_buffer_tree (name, doc);
else create_buffer (name, doc);
tm_view vw = concrete_view (get_passive_view (name));
tm_window win = tm_new<tm_window_rep> (doc, command ());
set_master_buffer (name, base);
vw->win= win;
set_scrollable (win->wid, vw->ed);
vw->ed->cvw= win->wid.rep;
vw->ed->mvw= curvw;
return wrapped_widget (win->wid, close_embedded_command (vw));
}
// reciever uses the function
int receive_file(int sock, struct sockaddr_in *send_adr, socklen_t *send_adr_sz, char *filename, uint32_t seg_size)
{
off_t current_filesize = get_file_size(filename);
uint32_t curr_segment_num = (current_filesize % seg_size != 0) ? 1 + current_filesize / seg_size : current_filesize / seg_size;
char response[MAX_BUFFER_SIZE];
ssize_t response_len;
buffer *b;
create_buffer(&b, 1024);
do {
response_len = timer_recvfrom(sock, response, MAX_BUFFER_SIZE, 0, (struct sockaddr *)send_adr, send_adr_sz, TIMEOUT, NUM_TRY);
akh_pdu_header *pheader = (akh_pdu_header *)response;
// time-out
if(response_len == -1)
return -1;
else if(pheader->msg_type == SS) {
printf("SS seq_num => %d\n", pheader->seq_num);
if(pheader->seq_num == curr_segment_num) {
write_segment(response + sizeof(akh_pdu_header), response_len - sizeof(akh_pdu_header), filename);
curr_segment_num++;
}
else {
push(b, response, response_len);
}
uint32_t temp;
do {
temp = curr_segment_num;
pop(b, response, &response_len);
pheader = (akh_pdu_header *)response;
if(pheader->seq_num == curr_segment_num) {
write_segment(response + sizeof(akh_pdu_header), response_len - sizeof(akh_pdu_header), filename);
curr_segment_num++;
}
push(b, response, response_len);
} while(pheader->seq_num == temp);
}
puts("< receive file segment >");
printf("msg_type = %x\tseq_num = %d\n", pheader->msg_type, pheader->seq_num);
} while(((akh_pdu_header *)response)->msg_type == SS);
return ((akh_pdu_header *)response)->msg_type;
}
int
main (int argc, char *argv[])
{
MechArea *scroll, *text;
MechWindow *window;
MechTextBuffer *buffer;
GMainLoop *main_loop;
gint n_paragraphs = 0;
if (argc > 1)
n_paragraphs = atoi (argv[1]);
if (n_paragraphs <= 0)
{
gchar *basename;
basename = g_filename_display_basename (argv[0]);
g_print ("Usage: %s <n-paragraphs>\n\n", basename);
n_paragraphs = 10000;
g_free (basename);
}
main_loop = g_main_loop_new (NULL, FALSE);
window = mech_window_new ();
mech_window_set_title (window, "Text");
g_signal_connect (window, "close-request",
G_CALLBACK (window_close_request), main_loop);
scroll = mech_scroll_area_new (MECH_AXIS_FLAG_Y);
mech_area_set_preferred_size (scroll, MECH_AXIS_X, MECH_UNIT_PX, 500);
mech_area_set_preferred_size (scroll, MECH_AXIS_Y, MECH_UNIT_PX, 500);
mech_area_add (mech_container_get_root (MECH_CONTAINER (window)), scroll);
text = mech_text_input_new ();
mech_area_add (scroll, text);
buffer = create_buffer (n_paragraphs);
mech_text_set_buffer (MECH_TEXT (text), buffer);
mech_window_set_visible (window, TRUE);
g_main_loop_run (main_loop);
return 0;
}
/*! Creates a duplicate of the \a buffer. The new buffer does not share internal
storage; they are completely independent from each other.
*/
static net_buffer *
duplicate_buffer(net_buffer *_buffer)
{
net_buffer_private *buffer = (net_buffer_private *)_buffer;
net_buffer* duplicate = create_buffer(0);
if (duplicate == NULL)
return NULL;
if (append_data(duplicate, buffer->data, buffer->size) != B_OK) {
free_buffer(duplicate);
return NULL;
}
copy_metadata(duplicate, buffer);
return duplicate;
}
void update_group_vertexarray(struct group *group)
{
struct groupdata *groupdata = group->data;
clear_buffer(groupdata->vertices);
buffer *buffer = create_buffer();
size_t blockcount = ptrarray_count(groupdata->blocks);
for (size_t i = 0; i < blockcount; ++i)
{
block *block = get_ptrarray(groupdata->blocks, i);
get_block_triangles(block, buffer);
append_triangles(groupdata, buffer);
clear_buffer(buffer);
}
destroy_buffer(buffer);
}
QVector<BufferSharedPtr>::iterator ShmPoolPrivate::reuseBuffer(const QSize &s,
qint32 stride,
Shm::Format format)
{
Q_Q(ShmPool);
// We can't return a shared pointer here so we just return
// the iterator of the buffers vector that can be used to
// retrieve the actual shared pointer
// Try to reuse an existing buffer
for (auto it = buffers.begin(); it != buffers.end(); ++it) {
QSharedPointer<Buffer> buffer = (*it);
// Skip buffers that are in use or do not match what the user is looking for
if (!buffer->isReleased() || buffer->isUsed())
continue;
if (buffer->size() != s || buffer->stride() != stride || buffer->format() != format)
continue;
// We found the buffer
buffer->setReleased(false);
return it;
}
// No buffer found: resize the pool to accomodate a new buffer
const qint32 bytesCount = s.height() * stride;
if (offset + bytesCount > size) {
if (!resizePool(bytesCount + size))
return Q_NULLPTR;
}
// No buffer can be reused, create a new one and advance the offset
wl_buffer *nativeBuffer =
create_buffer(offset, s.width(), s.height(), stride, format);
if (!nativeBuffer)
return Q_NULLPTR;
Buffer *buffer = new Buffer(q, s, stride, offset, format);
BufferPrivate::get(buffer)->init(nativeBuffer);
offset += bytesCount;
return buffers.insert(buffers.end(), BufferSharedPtr(buffer));
}
static void
drm_create_buffer(struct wl_client *client, struct wl_resource *resource,
uint32_t id, uint32_t name, int32_t width, int32_t height,
uint32_t stride, uint32_t format)
{
switch (format) {
case WL_DRM_FORMAT_ARGB8888:
case WL_DRM_FORMAT_XRGB8888:
case WL_DRM_FORMAT_YUYV:
break;
default:
wl_resource_post_error(resource,
WL_DRM_ERROR_INVALID_FORMAT,
"invalid format");
return;
}
create_buffer(client, resource, id,
name, -1, width, height, format, 0, stride, 0, 0, 0, 0);
}
int main(int argc, char *argv[])
{
gchar *message;
config_file = g_strdup_printf("%s/.gtktermrc", getenv("HOME"));
bindtextdomain(PACKAGE, LOCALEDIR);
bind_textdomain_codeset(PACKAGE, "UTF-8");
textdomain(PACKAGE);
gtk_init(&argc, &argv);
create_buffer();
create_main_window();
if(read_command_line(argc, argv) < 0)
{
delete_buffer();
exit(1);
}
Config_port();
message = get_port_string();
Set_window_title(message);
Set_status_message(message);
g_free(message);
add_shortcuts();
set_view(ASCII_VIEW);
gtk_main();
delete_buffer();
Close_port();
return 0;
}
int sb_alloc_larger_buffer(sb_connection_t *c)
{
sb_buffer_t *new_buffer=create_buffer(BUF_MIN_SIZE * 2);
if (new_buffer==NULL)
{
return -1;
}
sb_buffer_t *old_buffer=c->buffer;
if (old_buffer==NULL)
{
return -1;
}
memcpy(new_buffer->start,c->buffer->start,old_buffer->end-old_buffer->start);
new_buffer->pos=new_buffer->start+(old_buffer->pos-old_buffer->start);
new_buffer->last=new_buffer->start+(old_buffer->last-old_buffer->start);
return 0;
}
explicit openal_voice(const Device &device, Loader &&loader, bool loop)
: buffer_(create_buffer()), source_(create_source()) {
const auto format_data = loader.format();
ALenum format;
if (format_data.channels == 1) {
format = format_data.bits_per_sample == 8 ?
AL_FORMAT_MONO8 :
AL_FORMAT_MONO16;
} else {
format = format_data.bits_per_sample == 8 ?
AL_FORMAT_STEREO8 :
AL_FORMAT_STEREO16;
}
alBufferData(*buffer_,
format,
&(*loader.buffer()),
loader.size(),
format_data.samples_per_sec);
alSourcei(*source_, AL_BUFFER, *buffer_);
alSourcei(*source_, AL_LOOPING, loop ? AL_TRUE : AL_FALSE);
}
struct socket_buffer* socket_buffer_pool_get(struct socket_buffer_pool* pool)
{
struct socket_buffer* sb = NULL;
LOCK(pool)
if (pool->head != pool->tail)
{
sb = pool->queue[pool->head];
if ( ++pool->head >= pool->cap)
{
pool->head = 0;
}
}
else
sb = create_buffer();
sb->buffer.len = DEFAULT_SOCKET_BUFFER_SIZE;
UNLOCK(pool)
return sb;
}
void xml_formatter(FILE * f, const struct poem *p, GList * verses)
{
struct buffer * buf = create_buffer(XML_INITIAL_BUFFER_SIZE);
append_buffer(buf, "<?xml version=\"1.0\" standalone=\"yes\"?>\n");
append_buffer(buf, "<poem>\n");
append_buffer(buf, " <name>");
append_buffer(buf, get_poem_name(p));
append_buffer(buf, "</name>\n");
if (verses)
g_list_foreach(verses, (GFunc)xml_format_verse, buf);
else
each_verse(p, xml_format_verse, buf);
append_buffer(buf, "</poem>\n");
fprintf(f, "%s\n", get_buffer_string(buf));
destroy_buffer(buf);
}
DeferredPipeline::OutputMerger::OutputMerger(DeferredPipeline & parent, ID3D11Device & device, HWND hWnd, std::vector<Output_Merger_Material_Component>& materials) : PipelineStage(parent)
{
if (FAILED(_initialise_vertex_shader_and_layout(device, hWnd, L"shaders/output_merger_vertex_shader.hlsl"))) {
throw deferred_exception("Error initialising vertex shader / vertex layout for output merger pipeline stage");
}
std::ostringstream number_convert;
number_convert << materials.size();
std::string material_number = number_convert.str();
number_convert.str("");
number_convert << (int)_parent._viewport.Height;
std::string window_height = number_convert.str();
number_convert.str("");
number_convert << (int)_parent._viewport.Width;
std::string window_width = number_convert.str();
D3D_SHADER_MACRO defines[] = {
{ "MATERIAL_NUMBER", material_number.c_str() },
{ "WINDOW_HEIGHT", window_height.c_str() },
{ "WINDOW_WIDTH", window_width.c_str() },
{nullptr, nullptr}
};
if (FAILED(_initialise_pixel_shader(device, hWnd, L"shaders/output_merger_pixel_shader.hlsl", "PS", defines))) {
throw deferred_exception("Error initialising pixel shader for output merger pipeline stage");
}
if (FAILED(_initialise_sampler(device, D3D11_FILTER_MIN_MAG_MIP_POINT))) {
throw deferred_exception("Error initialising sampler for output_merger pipeline stage");
}
D3D11_SUBRESOURCE_DATA init_data;
ZeroMemory(&init_data, sizeof(init_data));
init_data.pSysMem = materials.data();
if (FAILED(create_buffer(device, D3D11_USAGE_IMMUTABLE, sizeof(Output_Merger_Material_Component) * materials.size(), D3D11_BIND_CONSTANT_BUFFER, 0, &_ps_materials_buffer, &init_data))) {
throw deferred_exception("Error initialising pixel constant buffer for lighting pipeline stage");
}
}
/* Please see header for specification */
Anvil::Buffer::Buffer(Anvil::Device* device_ptr,
VkDeviceSize size,
QueueFamilyBits queue_families,
VkSharingMode queue_sharing_mode,
VkBufferUsageFlags usage_flags)
:m_buffer (VK_NULL_HANDLE),
m_buffer_size (size),
m_device_ptr (device_ptr),
m_memory_block_ptr (nullptr),
m_parent_buffer_ptr(0),
m_start_offset (0),
m_usage_flags (static_cast<VkBufferUsageFlagBits>(usage_flags) )
{
/* Create the buffer object */
create_buffer(queue_families,
queue_sharing_mode,
size);
/* Register the object */
Anvil::ObjectTracker::get()->register_object(Anvil::ObjectTracker::OBJECT_TYPE_BUFFER,
this);
}
void binary_writer::write_empty(int sz)
{
int sz0 = sz;
int rem_size = _current_buffer_length - _current_offset;
if (rem_size >= sz)
{
_current_offset += sz;
}
else
{
_current_offset += rem_size;
sz -= rem_size;
int allocSize = _reserved_size_per_buffer;
if (sz > allocSize)
allocSize = sz;
create_buffer(allocSize);
_current_offset += sz;
}
_total_size += sz0;
}
frameBuffer::frameBuffer() {
// Open the file for reading and writing
fbfd = open("/dev/fb0", O_RDWR);
if (fbfd == -1) {
perror("Error: cannot open framebuffer device");
exit(1);
}
printf("The framebuffer device was opened successfully.\n");
// Get fixed screen information
if (ioctl(fbfd, FBIOGET_FSCREENINFO, &finfo) == -1) {
perror("Error reading fixed information");
exit(2);
}
// Get variable screen information
if (ioctl(fbfd, FBIOGET_VSCREENINFO, &vinfo) == -1) {
perror("Error reading variable information");
exit(3);
}
printf("%dx%d, %dbpp\n", vinfo.xres, vinfo.yres, vinfo.bits_per_pixel);
// Figure out the size of the screen in bytes
screensize = vinfo.xres * vinfo.yres * vinfo.bits_per_pixel / 8;
// Map the device to memory
fbp = (char *)mmap(0, screensize, PROT_READ | PROT_WRITE, MAP_SHARED, fbfd, 0);
if (atoi(fbp) == -1) {
perror("Error: failed to map framebuffer device to memory");
exit(4);
}
//printf("The framebuffer device was mapped to memory successfully.\n");
create_buffer();
}
