Lines Matching full:chunk
83 * bits 30-63: ram block chunk number, 2^34
190 struct ibv_mr **pmr; /* MRs for chunk-level registration */
191 struct ibv_mr *mr; /* MR for non-chunk-level registration */
192 uint32_t *remote_keys; /* rkeys for chunk-level registration */
193 uint32_t remote_rkey; /* rkeys for non-chunk-level registration */
317 /* index of the chunk in the current ram block */
419 * Register a single Chunk.
421 * to register an single chunk of memory before we can perform
427 uint64_t chunk; /* chunk to lookup if unregistering */ member
429 uint32_t current_index; /* which ramblock the chunk belongs to */
473 uint64_t length; /* length of the chunk */
627 * identify chunk boundaries inside each RAMBlock and also be referenced
1074 * Once the block is found, also identify which 'chunk' within that
1097 * Register a chunk with IB. If the chunk was already registered
1105 uint32_t *lkey, uint32_t *rkey, int chunk, in qemu_rdma_register_and_get_keys() argument
1118 /* allocate memory to store chunk MRs */ in qemu_rdma_register_and_get_keys()
1128 if (!block->pmr[chunk]) { in qemu_rdma_register_and_get_keys()
1135 block->pmr[chunk] = ibv_reg_mr(rdma->pd, chunk_start, len, access); in qemu_rdma_register_and_get_keys()
1142 if (!block->pmr[chunk] && in qemu_rdma_register_and_get_keys()
1146 block->pmr[chunk] = ibv_reg_mr(rdma->pd, chunk_start, len, access); in qemu_rdma_register_and_get_keys()
1149 if (block->pmr[chunk]) { in qemu_rdma_register_and_get_keys()
1151 len, block->pmr[chunk]->lkey, in qemu_rdma_register_and_get_keys()
1157 if (!block->pmr[chunk]) { in qemu_rdma_register_and_get_keys()
1163 *lkey = block->pmr[chunk]->lkey; in qemu_rdma_register_and_get_keys()
1166 *rkey = block->pmr[chunk]->rkey; in qemu_rdma_register_and_get_keys()
1205 uint64_t chunk = in qemu_rdma_unregister_waiting() local
1219 trace_qemu_rdma_unregister_waiting_proc(chunk, in qemu_rdma_unregister_waiting()
1237 clear_bit(chunk, block->unregister_bitmap); in qemu_rdma_unregister_waiting()
1239 if (test_bit(chunk, block->transit_bitmap)) { in qemu_rdma_unregister_waiting()
1240 trace_qemu_rdma_unregister_waiting_inflight(chunk); in qemu_rdma_unregister_waiting()
1244 trace_qemu_rdma_unregister_waiting_send(chunk); in qemu_rdma_unregister_waiting()
1246 ret = ibv_dereg_mr(block->pmr[chunk]); in qemu_rdma_unregister_waiting()
1247 block->pmr[chunk] = NULL; in qemu_rdma_unregister_waiting()
1248 block->remote_keys[chunk] = 0; in qemu_rdma_unregister_waiting()
1251 error_report("unregistration chunk failed: %s", in qemu_rdma_unregister_waiting()
1257 reg.key.chunk = chunk; in qemu_rdma_unregister_waiting()
1266 trace_qemu_rdma_unregister_waiting_complete(chunk); in qemu_rdma_unregister_waiting()
1273 uint64_t chunk) in qemu_rdma_make_wrid() argument
1278 result |= (chunk << RDMA_WRID_CHUNK_SHIFT); in qemu_rdma_make_wrid()
1320 uint64_t chunk = in qemu_rdma_poll() local
1327 index, chunk, block->local_host_addr, in qemu_rdma_poll()
1330 clear_bit(chunk, block->transit_bitmap); in qemu_rdma_poll()
1831 * Write an actual chunk of memory using RDMA.
1844 uint64_t chunk, chunks; in qemu_rdma_write_one() local
1860 chunk = ram_chunk_index(block->local_host_addr, in qemu_rdma_write_one()
1862 chunk_start = ram_chunk_start(block, chunk); in qemu_rdma_write_one()
1882 chunk_end = ram_chunk_end(block, chunk + chunks); in qemu_rdma_write_one()
1885 while (test_bit(chunk, block->transit_bitmap)) { in qemu_rdma_write_one()
1887 trace_qemu_rdma_write_one_block(count++, current_index, chunk, in qemu_rdma_write_one()
1894 "block %d chunk %" PRIu64 in qemu_rdma_write_one()
1896 current_index, chunk, sge.addr, length, rdma->nb_sent); in qemu_rdma_write_one()
1902 if (!block->remote_keys[chunk]) { in qemu_rdma_write_one()
1904 * This chunk has not yet been registered, so first check to see in qemu_rdma_write_one()
1905 * if the entire chunk is zero. If so, tell the other size to in qemu_rdma_write_one()
1906 * memset() + madvise() the entire chunk without RDMA. in qemu_rdma_write_one()
1920 trace_qemu_rdma_write_one_zero(chunk, sge.length, in qemu_rdma_write_one()
1953 reg.key.chunk = chunk; in qemu_rdma_write_one()
1957 trace_qemu_rdma_write_one_sendreg(chunk, sge.length, current_index, in qemu_rdma_write_one()
1969 &sge.lkey, NULL, chunk, in qemu_rdma_write_one()
1980 trace_qemu_rdma_write_one_recvregres(block->remote_keys[chunk], in qemu_rdma_write_one()
1981 reg_result->rkey, chunk); in qemu_rdma_write_one()
1983 block->remote_keys[chunk] = reg_result->rkey; in qemu_rdma_write_one()
1988 &sge.lkey, NULL, chunk, in qemu_rdma_write_one()
1995 send_wr.wr.rdma.rkey = block->remote_keys[chunk]; in qemu_rdma_write_one()
2000 &sge.lkey, NULL, chunk, in qemu_rdma_write_one()
2008 * Encode the ram block index and chunk within this wrid. in qemu_rdma_write_one()
2011 * chunk in the bitmap to look for. in qemu_rdma_write_one()
2014 current_index, chunk); in qemu_rdma_write_one()
2023 trace_qemu_rdma_write_one_post(chunk, sge.addr, send_wr.wr.rdma.remote_addr, in qemu_rdma_write_one()
2049 set_bit(chunk, block->transit_bitmap); in qemu_rdma_write_one()
2123 * Only merge into chunk sequentially. in qemu_rdma_buffer_mergeable()
2147 * 1. Identify the chunk the buffer belongs to.
2148 * 2. If the chunk is full or the buffer doesn't belong to the current
2149 * chunk, then start a new chunk and flush() the old chunk.
2152 * queue instead of each individual chunk.
2160 uint64_t chunk = rdma->current_chunk; in qemu_rdma_write() local
2171 offset, len, &index, &chunk); in qemu_rdma_write()
2173 rdma->current_chunk = chunk; in qemu_rdma_write()
3056 * Add this page to the current 'chunk'. If the chunk in qemu_rdma_save_page()
3057 * is full, or the page doesn't belong to the current chunk, in qemu_rdma_save_page()
3058 * an actual RDMA write will occur and a new chunk will be formed. in qemu_rdma_save_page()
3494 uint64_t chunk; in rdma_registration_handle() local
3522 chunk = ram_chunk_index(block->local_host_addr, in rdma_registration_handle()
3525 chunk = reg->key.chunk; in rdma_registration_handle()
3527 (reg->key.chunk * (1UL << RDMA_REG_CHUNK_SHIFT)); in rdma_registration_handle()
3528 /* Check for particularly bad chunk value */ in rdma_registration_handle()
3530 error_report("rdma: bad chunk for block %s" in rdma_registration_handle()
3531 " chunk: %" PRIx64, in rdma_registration_handle()
3532 block->block_name, reg->key.chunk); in rdma_registration_handle()
3536 chunk_start = ram_chunk_start(block, chunk); in rdma_registration_handle()
3537 chunk_end = ram_chunk_end(block, chunk + reg->chunks); in rdma_registration_handle()
3542 chunk, chunk_start, chunk_end)) { in rdma_registration_handle()
3573 reg->current_index, reg->key.chunk); in rdma_registration_handle()
3577 ret = ibv_dereg_mr(block->pmr[reg->key.chunk]); in rdma_registration_handle()
3578 block->pmr[reg->key.chunk] = NULL; in rdma_registration_handle()
3581 error_report("rdma unregistration chunk failed: %s", in rdma_registration_handle()
3588 trace_rdma_registration_handle_unregister_success(reg->key.chunk); in rdma_registration_handle()
3741 * (dynamic chunk registration disabled - pin everything with one rkey.) in rdma_registration_stop()
3743 * (dynamic chunk registration enabled - pin individual chunks.) in rdma_registration_stop()