int main(int argc, char ** argv) { /* The stack */ chunk_addr stack[STACK_SIZE]; /* Iterative variables */ int i, j; /* The memory manager */ memory_manager mem; /* Create the stack */ /* Create a new memory manager that should not have to grow. */ mem = new_memory_manager(STACK_SIZE * chunk_size(CHUNK_SIZE)); /* For ever: Loop throught the stack. Allocate a new piece of data to stack. */ for (j = 0; j < ITERATIONS; j++) { for (i = 0; i < STACK_SIZE; i++) { stack[i] = allocate(stack, stack + 1, CHUNK_SIZE, mem); } } /* Shutdown the memory manager. */ shutdown_memory_manager(mem); return EXIT_SUCCESS; }
int iforward_write( iforward_t *file, forward_t *forward ) { uint8_t *cbuff = chunk_compress( &forward->chunk, &forward->h.bcount ); forward->h.N = chunk_size( &forward->chunk ); fwrite( &forward->h, sizeof(forward->h), 1, file->in ); fwrite( cbuff, forward->h.bcount, 1, file->in ); free(cbuff); return 0; }
void SessionData::SendBytesToProcess (vector<string>* packets, vector<aux::output_packet>* out_packets, bool split_packets) { //чтобы порции трафика не ограничивались рамками одного пакета, но и можно было сделать закрытие соединения string prev_packet_chunk; vector<string>::const_iterator it; vector<aux::output_packet>::iterator it2; for (it = packets->begin(), it2 = out_packets->begin(); it != packets->end(); ++it, ++it2) { Sleep (Configure::GetConfiguration().TimeoutBetweenChunks()); string pckt = *it; if (prev_packet_chunk.size()) { pckt = prev_packet_chunk; string pckt2 (*it); pckt.append (pckt2.c_str()); prev_packet_chunk.clear(); } const char* begin = pckt.c_str(); const char* end = begin + pckt.size(); char* start = const_cast<char*>(begin); while (start != end) { size_t chunk_size (aux::rnd_chunk_size(Configure::GetConfiguration().MaximumChunkSize())); if (chunk_size >= static_cast<size_t>(end - start)) { if (split_packets || it2->dsDataTarget != ((it+1 != packets->end())?(it2+1)->dsDataTarget : it2->dsDataTarget)) { chunk_size = static_cast<size_t>(end - start); _ASSERTE (TranslateData(start, start + chunk_size, it2->dsDataTarget)); start += chunk_size; } else { prev_packet_chunk.assign (start, end); break; } } else { _ASSERTE(TranslateData(start, start + chunk_size, it2->dsDataTarget)); start += chunk_size; } Sleep (Configure::GetConfiguration().TimeoutBetweenChunks()); } } if (prev_packet_chunk.size()) { _ASSERTE(TranslateData (prev_packet_chunk.c_str(), prev_packet_chunk.c_str() + prev_packet_chunk.size(), out_packets->rbegin()->dsDataTarget)); } }
__AGENCY_ANNOTATION value_type operator*() const { auto end_of_current_chunk = base(); ++end_of_current_chunk; if(end_of_current_chunk == end()) { auto size_of_last_chunk = end().base() - base().base(); return value_type(base().base(), size_of_last_chunk); } return value_type(base().base(), chunk_size()); }
void * realloc(void *ptr, size_t size) { void *ret; size_t as; if (!size) { free(ptr); return (NULL); } as = chunk_size(ptr); if (size <= as) return (ptr); ret = malloc(size); if (ret) { memcpy(ret, ptr, MIN(as, size)); free(ptr); } return (ret); }
// https://wiki.libsdl.org/SDL_RWops?highlight=%28%5CbCategoryStruct%5Cb%29%7C%28CategoryIO%29 // https://wiki.libsdl.org/SDL_RWwrite?highlight=%28%5CbCategoryIO%5Cb%29%7C%28CategoryEnum%29%7C%28CategoryStruct%29 void hex_grid_t::save_to_file(std::string const& filepath) { WARN_IF(!chunks.empty(), "Saving an empty map"); SDL_RWops* io = SDL_RWFromFile(filepath.c_str(), "wb"); if(!io) { EXPLODE("hex_grid_t::save_to_file() error"); //todo: handle errors better } hxm_header_t header; header.version = 0; header.chunk_size = chunk_size(); header.map_size = size; size_t num_written = SDL_RWwrite(io, (void*)&header, sizeof(hxm_header_t), 1); if(num_written != 1) { EXPLODE("error writing hxm header"); } for_each_chunk([&](hex_grid_chunk_t const& chunk) { SDL_RWwrite(io, (void*)&chunk.size, sizeof(glm::uvec2), 1); for(auto column : chunk.cells) { size_t num_w = SDL_RWwrite(io, column.data(), sizeof(hex_grid_cell_t), column.size()); ASSERT(num_w == column.size(), "chunk save error"); LOG("wrote %d cells", num_w); } }); SDL_RWclose(io); }
__AGENCY_ANNOTATION difference_type size() const { return (end().base().base() - begin().base().base() + chunk_size() - 1) / (chunk_size()); }
static int __init l4ser_shm_init_port(int num, const char *name) { int irq; struct chunk_head *ch; struct l4ser_shm_uart_port *p = &l4ser_shm_port[num]; L4XV_V(f); if (p->inited) return 0; p->inited = 1; if (shmsize < PAGE_SIZE) shmsize = PAGE_SIZE; pr_info("l4ser_shm: Requesting, role %s, Shmsize %d Kbytes\n", p->create ? "Creator" : "User", shmsize >> 10); L4XV_L(f); if (p->create) { if (l4shmc_create(name, shmsize)) { L4XV_U(f); pr_err("l4ser_shm/%s: Failed to create shm\n", p->name); return -ENOMEM; } } if (l4shmc_attach_to(name, WAIT_TIMEOUT, &p->shmcarea)) { L4XV_U(f); pr_err("l4ser_shm/%s: Failed to attach to shm\n", p->name); return -ENOMEM; } if (l4shmc_add_chunk(&p->shmcarea, p->create ? "joe" : "bob", chunk_size(&p->shmcarea), &p->tx_chunk)) goto unlock; if (l4shmc_add_signal(&p->shmcarea, p->create ? "joe" : "bob", &p->tx_sig)) goto unlock; if (l4shmc_connect_chunk_signal(&p->tx_chunk, &p->tx_sig)) goto unlock; /* Now get the receiving side */ if (l4shmc_get_chunk_to(&p->shmcarea, p->create ? "bob" : "joe", WAIT_TIMEOUT, &p->rx_chunk)) goto unlock; if (l4shmc_get_signal_to(&p->shmcarea, p->create ? "bob" : "joe", WAIT_TIMEOUT, &p->rx_sig)) goto unlock; if (l4shmc_connect_chunk_signal(&p->rx_chunk, &p->rx_sig)) goto unlock; L4XV_U(f); if ((irq = l4x_register_irq(l4shmc_signal_cap(&p->rx_sig))) < 0) return -ENOMEM; ch = (struct chunk_head *)l4shmc_chunk_ptr(&p->tx_chunk); ch->next_offs_to_write = 0; ch->next_offs_to_read = 0; ch->writer_blocked = 0; p->tx_ring_size = l4shmc_chunk_capacity(&p->tx_chunk) - sizeof(struct chunk_head); p->rx_ring_size = l4shmc_chunk_capacity(&p->rx_chunk) - sizeof(struct chunk_head); p->tx_ring_start = (char *)l4shmc_chunk_ptr(&p->tx_chunk) + sizeof(struct chunk_head); p->rx_ring_start = (char *)l4shmc_chunk_ptr(&p->rx_chunk) + sizeof(struct chunk_head); p->port.uartclk = 3686400; p->port.ops = &l4ser_shm_pops; p->port.fifosize = 8; p->port.line = num; p->port.iotype = UPIO_MEM; p->port.membase = (void *)1; p->port.mapbase = 1; p->port.flags = UPF_BOOT_AUTOCONF; p->port.irq = irq; return 0; unlock: L4XV_U(f); return -ENOMEM; }
// chunk_head_t, followed by a varint compressed chunk of data. int ifile_real_read( ifile_t *file ) { size_t rc = fread( &file->h, sizeof(file->h), 1, file->in ); if( rc == 0 ) { // Nothering read, EOF return -1; } return read_block( file->in, file->h.N, file->h.bcount, &file->chunk ); } // Write's a chunk to disk. Format is chunk_head_t followed by varint compressed buffer void ifile_real_write( ifile_t *file ) { // Create the chunk_heaad_t object and compress body chunk_head_t h = { .N = chunk_size(&file->chunk), .term = file->h.term, .doc = file->h.doc }; uint8_t *cbuff = chunk_compress( &file->chunk, &h.bcount ); fwrite( &h, sizeof(h), 1, file->in ); fwrite( cbuff, h.bcount, 1, file->in ); free(cbuff); } // Read next tuple (term, doc) from the index. int ifile_read( ifile_t *file ) { // Get the next doc from the buffer if( chunk_get(&file->chunk, &file->roff, &file->tupe.doc ) == 0 ) { return 0; } else if( ifile_real_read( file ) ) { // Try reading a chunk of buffer is empty or we drained it return -1;