This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "Triton Repository".
The branch, master has been updated
via 10d474c070b743303810d89f7514f3d06a885153 (commit)
via 6da056d728b25dab6318177c92fa65f1237655a0 (commit)
from e0c571fadd3fbe0441e3bc147e230250c55b0b7a (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 10d474c070b743303810d89f7514f3d06a885153
Author: Phil Carns <carns(a)mcs.anl.gov>
Date: Fri Oct 29 08:54:31 2010 -0400
refactor rosd_write()
commit 6da056d728b25dab6318177c92fa65f1237655a0
Author: Phil Carns <carns(a)mcs.anl.gov>
Date: Thu Oct 28 16:55:29 2010 -0400
refactor rosd_remove(); untested
-----------------------------------------------------------------------
Summary of changes:
code/src/kv/kv.aer | 3 +-
code/src/replicated-osd/replicated-osd.aer | 536 +++++++++++---------
code/src/replicated-osd/replicated-osd.haer | 39 ++-
.../src/replicated-osd/tests/rosd-create-bench.aer | 6 +-
4 files changed, 346 insertions(+), 238 deletions(-)
Diff of changes:
diff --git a/code/src/kv/kv.aer b/code/src/kv/kv.aer
index 9279972..c3f7753 100644
--- a/code/src/kv/kv.aer
+++ b/code/src/kv/kv.aer
@@ -74,13 +74,12 @@ __blocking triton_ret_t triton_kv_put(triton_string_t *key, uint64_t value)
ret = triton_place_lookup(oid, 1, &addr);
req = malloc(sizeof(struct rosd_write_req));
- /* TODO: need to check if all arguments are properly set */
+ memset(&req->buffer, 0, sizeof(req->buffer));
req->buffer.buffer = (char*)&value;
req->buffer.size = sizeof(value);
req->buffer.alloc_size = req->buffer.size;
req->offset = 0;
req->flags = 0;
- req->txn_number = 0;
ret = remote_rosd_write(rctx, addr, req, &out);
if(ret != TRITON_SUCCESS)
diff --git a/code/src/replicated-osd/replicated-osd.aer b/code/src/replicated-osd/replicated-osd.aer
index b06d708..00ecded 100644
--- a/code/src/replicated-osd/replicated-osd.aer
+++ b/code/src/replicated-osd/replicated-osd.aer
@@ -116,11 +116,11 @@ static __blocking triton_ret_t get_placement_info(
}
-/* rosd_remove_local()
+/* rosd_remove_local_storage()
*
* performs the local steps needed in a replicated remove
*/
-__blocking triton_ret_t rosd_remove_local(
+__blocking triton_ret_t rosd_remove_local_storage(
uint128_t oid
)
{
@@ -214,6 +214,179 @@ __blocking triton_ret_t rosd_create_local_storage(
return(tret);
}
+/* rosd_write_local_storage()
+ *
+ * performs the local steps needed in a replicated write
+ */
+__blocking triton_ret_t rosd_write_local_storage(
+ uint128_t oid,
+ uint64_t fork,
+ uint64_t txn_number,
+ triton_buffer_t buffer,
+ int64_t offset
+)
+{
+ triton_ret_t tret;
+ uint64_t niid = 0;
+ int value = 0;
+ char* buffer_offsets[1];
+ int64_t big_size = buffer.size;
+
+ /* NOTE: a typical write is idempotent; no need for niid information
+ * here
+ */
+ buffer_offsets[0] = buffer.buffer;
+ tret = vosd_write(oid, fork, txn_number, buffer_offsets, &big_size,
+ 1, &offset, &big_size, 1, VOSD_FLAG_AUTO_TXN, 0);
+ if(tret != TRITON_SUCCESS)
+ {
+ triton_log_error(NULL, tret, "vosd_write()");
+ }
+
+ /* TODO: remote code can't propigate fn errors yet */
+ assert(tret == TRITON_SUCCESS);
+
+ return(tret);
+}
+
+
+static __blocking triton_ret_t rosd_write_do_work(
+ uint128_t oid,
+ uint64_t fork,
+ triton_buffer_t buffer,
+ int64_t offset,
+ uint32_t flags,
+ uint32_t replication_factor,
+ uint64_t txn_number,
+ int my_position,
+ triton_addr_t peer_addr)
+{
+ triton_ret_t local_tret;
+ triton_ret_t remote_tret;
+ aer_remote_ctx_t rctx;
+ struct rosd_s2s_write_req req;
+ int32_t dummy_out;
+
+ /* right now only chained replication is supported */
+ /* TODO: implement fanout */
+ assert(!(flags & ROSD_FLAG_FANOUT));
+ flags |= ROSD_FLAG_CHAIN;
+
+ pwait
+ {
+ pprivate char oid_str[TRITON_UINT128_STRLEN];
+ pbranch
+ {
+ /* forward on to peers if necessary */
+ if(my_position == replication_factor-1)
+ {
+ /* end of the chain; no one further to forward to */
+ remote_tret = TRITON_SUCCESS;
+ }
+ else
+ {
+ triton_uint128_to_string(oid_str, TRITON_UINT128_STRLEN, oid);
+ triton_debug(rosd_dbg_mask, "ROSD forwarding write of oid %s to %d'th server.\n", oid_str, my_position+1);
+ aesop_hints_get("triton.remote.context", sizeof(rctx), &rctx);
+ /* TODO: error check above; we are in trouble if hint not
+ * found
+ */
+ req.oid = oid;
+ req.fork = fork;
+ memset(&req.buffer, 0, sizeof(req.buffer)); /* for safety */
+ req.buffer.buffer = buffer.buffer;
+ req.buffer.size = buffer.size;
+ req.buffer.alloc_size = req.buffer.size;
+ req.offset = offset;
+ req.flags = ROSD_FLAG_CHAIN;
+ req.replication_factor = replication_factor;
+ req.txn_number = txn_number;
+ remote_tret = remote_rosd_s2s_write(rctx, peer_addr, &req, &dummy_out);
+ }
+ }
+ pbranch
+ {
+ triton_uint128_to_string(oid_str, TRITON_UINT128_STRLEN, oid);
+ triton_debug(rosd_dbg_mask, "ROSD local write of oid %s on %d'th server.\n", oid_str, my_position);
+ /* perform local operation */
+ local_tret = rosd_write_local_storage(oid, fork, txn_number,
+ buffer, offset);
+ }
+ }
+
+ /* TODO: handle cases where one of local or remote succeeded, but not
+ * both. What to clean up, and what to leave to the resync process?
+ */
+
+ /* TODO: remote code can't propigate fn errors yet */
+ assert(local_tret == TRITON_SUCCESS && remote_tret == TRITON_SUCCESS);
+ return(local_tret);
+}
+
+
+static __blocking triton_ret_t rosd_remove_do_work(
+ uint128_t oid,
+ uint32_t flags,
+ uint32_t replication_factor,
+ int my_position,
+ triton_addr_t peer_addr)
+{
+ triton_ret_t local_tret;
+ triton_ret_t remote_tret;
+ aer_remote_ctx_t rctx;
+ struct rosd_s2s_remove_req req;
+ int32_t dummy_out;
+
+ /* right now only chained replication is supported */
+ /* TODO: implement fanout */
+ assert(!(flags & ROSD_FLAG_FANOUT));
+ flags |= ROSD_FLAG_CHAIN;
+
+ pwait
+ {
+ pprivate char oid_str[TRITON_UINT128_STRLEN];
+ pbranch
+ {
+ /* forward on to peers if necessary */
+ if(my_position == replication_factor-1)
+ {
+ /* end of the chain; no one further to forward to */
+ remote_tret = TRITON_SUCCESS;
+ }
+ else
+ {
+ triton_uint128_to_string(oid_str, TRITON_UINT128_STRLEN, oid);
+ triton_debug(rosd_dbg_mask, "ROSD forwarding remove of oid %s to %d'th server.\n", oid_str, my_position+1);
+ aesop_hints_get("triton.remote.context", sizeof(rctx), &rctx);
+ /* TODO: error check above; we are in trouble if hint not
+ * found
+ */
+ req.oid = oid;
+ req.flags = ROSD_FLAG_CHAIN;
+ req.replication_factor = replication_factor;
+ remote_tret = remote_rosd_s2s_remove(rctx, peer_addr, &req, &dummy_out);
+ }
+ }
+ pbranch
+ {
+ triton_uint128_to_string(oid_str, TRITON_UINT128_STRLEN, oid);
+ triton_debug(rosd_dbg_mask, "ROSD local remove of oid %s on %d'th server.\n", oid_str, my_position);
+ /* perform local operation */
+ local_tret = rosd_remove_local_storage(oid);
+ }
+ }
+
+ /* TODO: handle cases where one of local or remote succeeded, but not
+ * both. What to clean up, and what to leave to the resync process?
+ */
+
+ /* TODO: remote code can't propigate fn errors yet */
+ assert(local_tret == TRITON_SUCCESS && remote_tret == TRITON_SUCCESS);
+ return(local_tret);
+}
+
+
+
static __blocking triton_ret_t rosd_create_do_work(
uint128_t oid,
uint32_t flags,
@@ -323,8 +496,8 @@ __remote __blocking triton_ret_t rosd_s2s_create(
assert(tret == TRITON_SUCCESS);
/* this is a server request, so I should _not_ be the master. */
- /* TODO: need to handle this case; may have simply been a client with a
- * stale node list
+ /* TODO: need to handle this case; someone may just have a stale node
+ * list
*/
assert(my_position != 0);
@@ -341,145 +514,121 @@ __remote __blocking triton_ret_t rosd_s2s_create(
return(tret);
}
-__remote __blocking triton_ret_t rosd_remove(
- struct rosd_remove_req* req,
+__remote __blocking triton_ret_t rosd_s2s_remove(
+ struct rosd_s2s_remove_req* req,
int32_t* out_nothing
)
-{
- triton_ret_t local_tret;
- triton_ret_t remote_tret;
+{
+ triton_ret_t tret;
int my_position;
- int32_t out;
- triton_node_t* closest;
triton_addr_t peer_addr;
- int64_t out_size;
- int64_t obj_offset;
- int64_t size;
- char* buffer_offsets[1];
- triton_addr_t self;
- aer_remote_ctx_t rctx;
- self = triton_addr_self("mpi");
+ tret = get_placement_info(req->oid, req->replication_factor,
+ &my_position, &peer_addr);
+ /* TODO: rpc's can't propagate errors yet */
+ assert(tret == TRITON_SUCCESS);
+
+ /* this is a server to server request, so I should not be the master */
+ /* TODO: need to handle this case; someone may have a stale node list */
+ assert(my_position != 0);
- /* right now only chained replication is supported */
- /* TODO: implement fanout */
- assert(!(req->flags & ROSD_FLAG_FANOUT));
- req->flags |= ROSD_FLAG_CHAIN;
+ tret = rosd_remove_do_work(
+ req->oid,
+ req->flags,
+ req->replication_factor,
+ my_position,
+ peer_addr);
- /* retrieve the replication factor from the object if it isn't already
- * set in the request
- */
- if(req->replication_factor < 1)
- {
- obj_offset = 0;
- buffer_offsets[0] = (char*)&req->replication_factor;
- size = sizeof(req->replication_factor);
- local_tret = vosd_read(req->oid, REP_FACTOR_FORK, buffer_offsets,
- &size, 1, &obj_offset, &size, 1, &out_size, 0);
- /* TODO: error handling */
- assert(local_tret == TRITON_SUCCESS &&
- out_size == sizeof(req->replication_factor));
- }
+ /* TODO: rpc's can't propagate errors yet */
+ assert(tret == TRITON_SUCCESS);
- out_nothing = NULL;
+ return(tret);
+}
- /* find out who are peers are */
- closest = malloc(req->replication_factor * sizeof(*closest));
- /* TODO: remote code can't propigate fn errors yet */
- assert(closest != NULL);
- local_tret =
- triton_place_lookup(req->oid, req->replication_factor, closest);
- /* TODO: remote code can't propigate fn errors yet */
- assert(local_tret == TRITON_SUCCESS);
- /* what position am I in the replication chain? */
- local_tret = triton_place_replica(self, closest, &my_position);
- /* TODO: remote code can't propigate fn errors yet */
- assert(local_tret == TRITON_SUCCESS);
+__remote __blocking triton_ret_t rosd_remove(
+ struct rosd_remove_req* req,
+ int32_t* out_nothing
+)
+{
+ triton_ret_t tret;
+ int my_position;
+ triton_addr_t peer_addr;
+ int64_t obj_offset;
+ int64_t size;
+ int64_t out_size;
+ char* buffer_offsets[1];
+ uint32_t replication_factor;
-#if 0
- /* this better be a server-to-server request if I'm not the master */
- /* TODO: real handling; may have been a client with stale node list */
- assert((my_position == 0 && !(req->flags & ROSD_FLAG_S2S)) ||
- (my_position > 0 && (req->flags & ROSD_FLAG_S2S)));
-#endif
+ /* retrieve the replication factor from the object */
+ obj_offset = 0;
+ buffer_offsets[0] = (char*)&replication_factor;
+ size = sizeof(replication_factor);
+ tret = vosd_read(req->oid, REP_FACTOR_FORK, buffer_offsets,
+ &size, 1, &obj_offset, &size, 1, &out_size, 0);
+ /* TODO: error handling */
+ assert(tret == TRITON_SUCCESS &&
+ out_size == sizeof(replication_factor));
- pwait
- {
- pprivate char oid_str[TRITON_UINT128_STRLEN];
- pbranch
- {
- /* forward on to peers if necessary */
- if(my_position == req->replication_factor-1)
- {
- /* end of the chain; no one further to forward to */
- remote_tret = TRITON_SUCCESS;
- }
- else
- {
- triton_uint128_to_string(oid_str, TRITON_UINT128_STRLEN, req->oid);
- triton_debug(rosd_dbg_mask, "ROSD forwarding remove of oid %s to %d'th server.\n", oid_str, my_position+1);
-#if 0
- req->flags |= ROSD_FLAG_S2S;
-#endif
- peer_addr = closest[my_position+1];
- aesop_hints_get("triton.remote.context", sizeof(rctx), &rctx);
- /* TODO: error check above; we are in trouble if hint not
- * found
- */
- remote_tret = remote_rosd_remove(rctx, peer_addr, req, &out);
- }
- }
- pbranch
- {
- triton_uint128_to_string(oid_str, TRITON_UINT128_STRLEN, req->oid);
- triton_debug(rosd_dbg_mask, "ROSD local remove of oid %s on %d'th server.\n", oid_str, my_position);
- /* perform local operation */
- local_tret = rosd_remove_local(req->oid);
- }
- }
+ tret = get_placement_info(req->oid, replication_factor,
+ &my_position, &peer_addr);
+ /* TODO: rpc's can't propagate errors yet */
+ assert(tret == TRITON_SUCCESS);
+
+ /* this is a client request, so I better be the master. */
+ /* TODO: need to handle this case; may have simply been a client with a
+ * stale node list
+ */
+ assert(my_position == 0);
- free(closest);
+ tret = rosd_remove_do_work(
+ req->oid,
+ req->flags,
+ replication_factor,
+ my_position,
+ peer_addr);
- /* TODO: handle cases where one of local or remote succeeded, but not
- * both. What to clean up, and what to leave to the resync process?
- */
+ /* TODO: rpc's can't propagate errors yet */
+ assert(tret == TRITON_SUCCESS);
- /* TODO: remote code can't propigate fn errors yet */
- assert(local_tret == TRITON_SUCCESS && remote_tret == TRITON_SUCCESS);
- return(local_tret);
+ return(tret);
}
-/* rosd_write_local()
- *
- * performs the local steps needed in a replicated write
- */
-__blocking triton_ret_t rosd_write_local(
- uint128_t oid,
- uint64_t fork,
- uint64_t txn_number,
- triton_buffer_t buffer,
- int64_t offset
+
+__remote __blocking triton_ret_t rosd_s2s_write(
+ struct rosd_s2s_write_req* req,
+ int32_t* out_nothing
)
{
triton_ret_t tret;
- uint64_t niid = 0;
- int value = 0;
+ int my_position;
+ triton_addr_t peer_addr;
+ int64_t obj_offset;
+ int64_t size;
+ int64_t out_size;
char* buffer_offsets[1];
- int64_t big_size = buffer.size;
- /* NOTE: a typical write is idempotent; no need for niid information
- * here
- */
- buffer_offsets[0] = buffer.buffer;
- tret = vosd_write(oid, fork, txn_number, buffer_offsets, &big_size,
- 1, &offset, &big_size, 1, VOSD_FLAG_AUTO_TXN, 0);
- if(tret != TRITON_SUCCESS)
- {
- triton_log_error(NULL, tret, "vosd_write()");
- }
+ tret = get_placement_info(req->oid, req->replication_factor,
+ &my_position, &peer_addr);
+ /* TODO: rpc's can't propagate errors yet */
+ assert(tret == TRITON_SUCCESS);
+
+ /* this is a server to server request, so I should not be the master */
+ /* TODO: need to handle this case; someone may have a stale node list */
+ assert(my_position != 0);
- /* TODO: remote code can't propigate fn errors yet */
+ tret = rosd_write_do_work(
+ req->oid,
+ req->fork,
+ req->buffer,
+ req->offset,
+ req->flags,
+ req->replication_factor,
+ req->txn_number,
+ my_position,
+ peer_addr);
+
+ /* TODO: rpc's can't propagate errors yet */
assert(tret == TRITON_SUCCESS);
return(tret);
@@ -491,128 +640,59 @@ __remote __blocking triton_ret_t rosd_write(
int32_t* out_nothing
)
{
- triton_ret_t local_tret;
- triton_ret_t remote_tret;
+ triton_ret_t tret;
int my_position;
- int32_t out;
- triton_node_t* closest;
triton_addr_t peer_addr;
- int64_t out_size;
int64_t obj_offset;
int64_t size;
+ int64_t out_size;
char* buffer_offsets[1];
- triton_addr_t self;
- aer_remote_ctx_t rctx;
-
- self = triton_addr_self("mpi");
+ uint32_t replication_factor;
+ uint64_t txn_number;
- /* right now only chained replication is supported */
- /* TODO: implement fanout */
- assert(!(req->flags & ROSD_FLAG_FANOUT));
- req->flags |= ROSD_FLAG_CHAIN;
+ /* retrieve the replication factor from the object */
+ obj_offset = 0;
+ buffer_offsets[0] = (char*)&replication_factor;
+ size = sizeof(replication_factor);
+ tret = vosd_read(req->oid, REP_FACTOR_FORK, buffer_offsets,
+ &size, 1, &obj_offset, &size, 1, &out_size, 0);
+ /* TODO: error handling */
+ assert(tret == TRITON_SUCCESS &&
+ out_size == sizeof(replication_factor));
- /* retrieve the replication factor from the object if it isn't already
- * set in the request
+ tret = get_placement_info(req->oid, replication_factor,
+ &my_position, &peer_addr);
+ /* TODO: rpc's can't propagate errors yet */
+ assert(tret == TRITON_SUCCESS);
+
+ /* this is a client request, so I better be the master. */
+ /* TODO: need to handle this case; may have simply been a client with a
+ * stale node list
*/
- if(req->replication_factor < 1)
- {
- obj_offset = 0;
- buffer_offsets[0] = (char*)&req->replication_factor;
- size = sizeof(req->replication_factor);
- local_tret = vosd_read(req->oid, REP_FACTOR_FORK, buffer_offsets,
- &size, 1, &obj_offset, &size, 1, &out_size, 0);
- /* TODO: error handling */
- assert(local_tret == TRITON_SUCCESS &&
- out_size == sizeof(req->replication_factor));
- }
-
- out_nothing = NULL;
-
- /* find out who are peers are */
- closest = malloc(req->replication_factor * sizeof(*closest));
- /* TODO: remote code can't propigate fn errors yet */
- assert(closest != NULL);
- local_tret =
- triton_place_lookup(req->oid, req->replication_factor, closest);
- /* TODO: remote code can't propigate fn errors yet */
- assert(local_tret == TRITON_SUCCESS);
-
- /* what position am I in the replication chain? */
- local_tret = triton_place_replica(self, closest, &my_position);
- /* TODO: remote code can't propigate fn errors yet */
- assert(local_tret == TRITON_SUCCESS);
-
-#if 0
- /* this better be a server-to-server request if I'm not the master */
- /* TODO: real handling; may have been a client with stale node list */
- assert((my_position == 0 && !(req->flags & ROSD_FLAG_S2S)) ||
- (my_position > 0 && (req->flags & ROSD_FLAG_S2S)));
-#endif
-
- if(my_position == 0)
- {
- /* master is responsible for coordinating the txn_number */
- /* TODO: error handling */
- assert(req->txn_number == 0); /* client isn't allowed to set this */
-
- /* TODO: need a data structure to keep track of current version
- * number; pick up here
- */
- req->txn_number = 2;
- }
- else
- {
- assert(req->txn_number > 0);
- }
+ assert(my_position == 0);
- pwait
- {
- pprivate char oid_str[TRITON_UINT128_STRLEN];
- pbranch
- {
- /* forward on to peers if necessary */
- if(my_position == req->replication_factor-1)
- {
- /* end of the chain; no one further to forward to */
- remote_tret = TRITON_SUCCESS;
- }
- else
- {
- triton_uint128_to_string(oid_str, TRITON_UINT128_STRLEN, req->oid);
- triton_debug(rosd_dbg_mask, "ROSD forwarding write of oid %s to %d'th server.\n", oid_str, my_position+1);
-#if 0
- req->flags |= ROSD_FLAG_S2S;
-#endif
- peer_addr = closest[my_position+1];
- aesop_hints_get("triton.remote.context", sizeof(rctx), &rctx);
- /* TODO: error check above; we are in trouble if hint not
- * found
- */
- remote_tret = remote_rosd_write(rctx, peer_addr, req, &out);
- }
- }
- pbranch
- {
- triton_uint128_to_string(oid_str, TRITON_UINT128_STRLEN, req->oid);
- triton_debug(rosd_dbg_mask, "ROSD local write of oid %s on %d'th server.\n", oid_str, my_position);
- /* perform local operation */
- local_tret = rosd_write_local(req->oid, req->fork, req->txn_number, req->buffer,
- req->offset);
- }
- }
+ /* TODO: need a data structure to keep track of current version
+ * number.... hard coding for now.
+ */
+ txn_number = 2;
- free(closest);
+ tret = rosd_write_do_work(
+ req->oid,
+ req->fork,
+ req->buffer,
+ req->offset,
+ req->flags,
+ replication_factor,
+ txn_number,
+ my_position,
+ peer_addr);
- /* TODO: handle cases where one of local or remote succeeded, but not
- * both. What to clean up, and what to leave to the resync process?
- */
+ /* TODO: rpc's can't propagate errors yet */
+ assert(tret == TRITON_SUCCESS);
- /* TODO: remote code can't propigate fn errors yet */
- assert(local_tret == TRITON_SUCCESS && remote_tret == TRITON_SUCCESS);
- return(local_tret);
+ return(tret);
}
-
/*
* Local variables:
* c-indent-level: 4
diff --git a/code/src/replicated-osd/replicated-osd.haer b/code/src/replicated-osd/replicated-osd.haer
index debffe7..4d7dd0b 100644
--- a/code/src/replicated-osd/replicated-osd.haer
+++ b/code/src/replicated-osd/replicated-osd.haer
@@ -47,7 +47,6 @@ __remote struct rosd_remove_req
{
uint128_t oid;
uint32_t flags;
- uint32_t replication_factor; /* can be zero if the client doesn't know it */
};
/**
@@ -64,10 +63,7 @@ __remote struct rosd_write_req
uint64_t fork;
triton_buffer_t buffer;
int64_t offset;
-
uint32_t flags;
- uint32_t replication_factor; /* should be zero coming from client */
- uint64_t txn_number; /* should be zero coming from client */
};
/**
@@ -100,6 +96,41 @@ __remote __blocking triton_ret_t rosd_s2s_create(
int32_t* out_nothing
);
+__remote struct rosd_s2s_remove_req
+{
+ uint128_t oid;
+ uint32_t flags;
+ uint32_t replication_factor;
+};
+
+/**
+ * Removes an object (server to server)
+ */
+__remote __blocking triton_ret_t rosd_s2s_remove(
+ struct rosd_s2s_remove_req* req,
+ int32_t* out_nothing
+);
+
+
+__remote struct rosd_s2s_write_req
+{
+ uint128_t oid;
+ uint64_t fork;
+ triton_buffer_t buffer;
+ int64_t offset;
+ uint32_t flags;
+ uint32_t replication_factor;
+ uint64_t txn_number;
+};
+
+/**
+ * Write data to an object (server to server)
+ */
+__remote __blocking triton_ret_t rosd_s2s_write(
+ struct rosd_s2s_write_req* req,
+ int32_t* out_nothing
+);
+
diff --git a/code/src/replicated-osd/tests/rosd-create-bench.aer b/code/src/replicated-osd/tests/rosd-create-bench.aer
index 987b271..d2c468d 100644
--- a/code/src/replicated-osd/tests/rosd-create-bench.aer
+++ b/code/src/replicated-osd/tests/rosd-create-bench.aer
@@ -208,7 +208,6 @@ __blocking void do_remote_remove(void)
req.oid = oid;
req.flags = 0;
triton_mutex_unlock(&oid_mutex);
- req.replication_factor = 0;
/* look up location of this object */
ret = triton_place_lookup(oid, 1, &svr_addr);
@@ -259,14 +258,13 @@ __blocking void do_remote_write(void)
req.oid = oid;
triton_mutex_unlock(&oid_mutex);
req.fork = 0;
+ memset(&req.buffer, 0, sizeof(req.buffer));
req.buffer.buffer = test_buffer;
req.buffer.size = strlen(test_buffer) + 1;
req.buffer.alloc_size = req.buffer.size;
req.offset = 0;
req.flags = 0;
- req.txn_number = 0; /* client doesn't set */
- req.replication_factor = 0; /* client doesn't set */
-
+
/* look up location of this object */
ret = triton_place_lookup(oid, 1, &svr_addr);
assert(ret == TRITON_SUCCESS);
hooks/post-receive
--
Triton Repository
