A ref change was pushed to the repository containing the project "Grayskull Repository". The branch, master has been updated via 64e1ad598885443d5789ec39423e7917833f3192 (commit) via 481c4c7817800d4121ec300e70f2ecc286ef3b07 (commit) via 68ef1bd38c3ec4c06eb4e72972eae62b9358dfc5 (commit) via 1fb79463ce8f4b1fe1ab5b95204c710ef48f93e2 (commit) via eba4cc00b430ac448db7bae92bc4095b3b8530e3 (commit) via 0e16ea414048df4bf946b7962b05793891631aec (commit) via ad2ad8ab57935136d120bb93a7ce391224f9fd58 (commit) via 844a6b67219c07969c4e056dc8736dcca28dc23e (commit) via 3f6aa4abc973f747586344b27e0747afa504fb71 (commit) via 0f5dee7abb6aa49db60fc9affd9378f28c4e00d1 (commit) via 04a97f354b67bfd89ae63fee69438ec6de9961a2 (commit) via 59f05df0a3566e7036bb5d97f8c183f66f6f758a (commit) via b51b809637f97e4f5f653660fbfe2592bbad1194 (commit) from 8f0ad1a9238818da3d1a0c2ab960e6342acea211 (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 64e1ad598885443d5789ec39423e7917833f3192 Author: Justin M Wozniak <[email protected]> Date: Tue Jul 28 16:31:38 2009 -0500 Reverting to previous version. Something strange happened with the email commit. commit 481c4c7817800d4121ec300e70f2ecc286ef3b07 Merge: 68ef1bd38c3ec4c06eb4e72972eae62b9358dfc5 8f0ad1a9238818da3d1a0c2ab960e6342acea211 Author: Justin M Wozniak <[email protected]> Date: Tue Jul 28 14:12:18 2009 -0500 Merge branch 'master' of /homes/dkimpe/git/grayskull commit 68ef1bd38c3ec4c06eb4e72972eae62b9358dfc5 Author: Justin M Wozniak <[email protected]> Date: Tue Jul 28 14:03:34 2009 -0500 Added GACK draft. commit 1fb79463ce8f4b1fe1ab5b95204c710ef48f93e2 Author: Justin M Wozniak <[email protected]> Date: Mon Jul 27 19:26:02 2009 -0500 Multiple changes. commit eba4cc00b430ac448db7bae92bc4095b3b8530e3 Merge: 0e16ea414048df4bf946b7962b05793891631aec 75b46b7fb9cd9c4b2ea47aea86de12a48ef176a8 Author: Justin Wozniak <[email protected]> Date: Wed Jul 22 12:55:21 2009 -0500 Merge branch 'master' of ssh://login3.mcs.anl.gov/~wozniak/proj/gs commit 0e16ea414048df4bf946b7962b05793891631aec Author: Justin Wozniak <[email protected]> Date: Wed Jul 22 12:53:34 2009 -0500 New GACK module. commit ad2ad8ab57935136d120bb93a7ce391224f9fd58 Author: Justin Wozniak <[email protected]> Date: Wed Jul 22 12:20:35 2009 -0500 Test for xtree ADT. commit 844a6b67219c07969c4e056dc8736dcca28dc23e Author: Justin Wozniak <[email protected]> Date: Wed Jul 22 11:29:03 2009 -0500 Added javadoc comments. commit 3f6aa4abc973f747586344b27e0747afa504fb71 Merge: 0f5dee7abb6aa49db60fc9affd9378f28c4e00d1 d9c95daae6cf4a28afaed3224d7c5a2b7277dfc3 Author: Justin Wozniak <[email protected]> Date: Tue Jul 21 17:01:52 2009 -0500 Merge branch 'master' of [email protected]:~dkimpe/git/grayskull commit 0f5dee7abb6aa49db60fc9affd9378f28c4e00d1 Merge: 04a97f354b67bfd89ae63fee69438ec6de9961a2 598da6d94a53b93960ca88b162e4c4372d752c5f Author: Justin Wozniak <[email protected]> Date: Tue Jul 21 14:34:33 2009 -0500 Merge branch 'master' of [email protected]:~dkimpe/git/grayskull commit 04a97f354b67bfd89ae63fee69438ec6de9961a2 Author: Justin Wozniak <[email protected]> Date: Tue Jul 21 14:32:29 2009 -0500 New addresses of arbitrary length. commit 59f05df0a3566e7036bb5d97f8c183f66f6f758a Author: Justin Wozniak <[email protected]> Date: Tue Jul 21 14:19:25 2009 -0500 Do not need Key.java . commit b51b809637f97e4f5f653660fbfe2592bbad1194 Author: Justin Wozniak <[email protected]> Date: Tue Jul 21 14:17:53 2009 -0500 New NodeScheme interface and support for large address lengths. ----------------------------------------------------------------------- Summary of changes: code/Makefile.in | 14 ++- code/configure.ac | 2 + ...ozniak_aproj_ags.git_acode_asrc_agack_agack.gs# | 3 + code/src/gack/gack.gs | 56 ++++++ code/src/{gum => gack}/module.mk.in | 8 +- code/src/gobs/ait.gs | 72 +++++++ code/src/gobs/dense/dense.gs | 199 +++++++++----------- code/src/gobs/gobs.gs | 154 ++++++++++++++- code/src/gobs/interpreter.gs | 8 - code/src/gobs/launch.gs | 4 +- code/src/gobs/module.mk.in | 6 +- code/src/include/ait.gsh | 12 ++ code/src/include/ait_types.gsh | 33 ++++ code/src/include/gack.gsh | 29 +++ code/src/include/gack_types.gsh | 13 ++ code/src/include/gobs.gsh | 70 +++++--- code/src/include/gobs_dense.h | 18 ++ code/src/include/gobs_types.gsh | 12 +- code/src/include/gum.gsh | 6 +- code/src/include/interpreter.gsh | 32 --- code/src/include/skullfs.gsh | 15 ++- code/src/include/skullfs_client.gsh | 14 ++- code/src/include/skullfs_handlers.gsh | 2 + code/src/include/skullfs_rpcs.gsh | 4 +- code/src/skullfs/client.gs | 146 +++++++++------ code/src/skullfs/handlers.gs | 87 +++++++-- code/src/skullfs/rpcs.gs | 42 ++--- code/src/skullfs/skullfs.gs | 60 ++++-- code/test/adts/test07.c | 43 +++++ code/test/common/gdb_wait_loop.c | 11 + code/test/gack/module.mk.in | 24 +++ code/test/{skullfs/test02.gs => gack/test01.gs} | 16 +- code/test/gobs/About.txt | 4 + code/test/gobs/test03.gs | 115 +---------- code/test/skullfs/About.txt | 5 +- code/test/skullfs/test02.gs | 4 +- code/test/skullfs/test05.gs | 21 ++- code/test/skullfs/{test05.gs => test06.gs} | 26 +-- code/test/skullfs/{test05.gs => test07.gs} | 33 ++-- sim/gobs/About.txt | 17 ++- sim/gobs/Addressable.java | 34 +++- sim/gobs/Bits.java | 3 +- sim/gobs/GOBS.java | 33 ++-- sim/gobs/Kademlia.java | 4 + sim/gobs/LayoutScheme.java | 4 + sim/gobs/Node.java | 4 + sim/gobs/NodeScheme.java | 10 +- sim/gobs/Obj.java | 5 +- sim/gobs/PlacementScheme.java | 4 + sim/gobs/RandomLayout.java | 4 + sim/gobs/RandomNodes.java | 6 +- sim/gobs/UniformNodes.java | 16 +- 52 files changed, 1030 insertions(+), 537 deletions(-) create mode 100644 code/src/gack/#_ascpx_blogin3.mcs.anl.gov_b_ahomes_awozniak_aproj_ags.git_acode_asrc_agack_agack.gs# create mode 100644 code/src/gack/gack.gs copy code/src/{gum => gack}/module.mk.in (50%) create mode 100644 code/src/gobs/ait.gs delete mode 100644 code/src/gobs/interpreter.gs create mode 100644 code/src/include/ait.gsh create mode 100644 code/src/include/ait_types.gsh create mode 100644 code/src/include/gack.gsh create mode 100644 code/src/include/gack_types.gsh delete mode 100644 code/src/include/interpreter.gsh create mode 100644 code/test/adts/test07.c create mode 100644 code/test/common/gdb_wait_loop.c create mode 100644 code/test/gack/module.mk.in copy code/test/{skullfs/test02.gs => gack/test01.gs} (57%) create mode 100644 code/test/gobs/About.txt copy code/test/skullfs/{test05.gs => test06.gs} (57%) copy code/test/skullfs/{test05.gs => test07.gs} (57%) Diff of changes: diff --git a/code/Makefile.in b/code/Makefile.in index 45de700..d5002c8 100644 --- a/code/Makefile.in +++ b/code/Makefile.in @@ -295,9 +295,11 @@ SKULLFS_GSSRC := TEST_GSSRC := GOBS_OBJS := +GACK_OBJS := ALL_GS = $(GUM_GSSRC) \ $(GOBS_GSSRC) src/gobs/launch.gs \ + $(GACK_GSSRC) \ $(SKULLFS_GSSRC) \ $(TEST_GSSRC) ALL_GS_I = $(patsubst %.gs, %.gs.i, $(ALL_GS)) @@ -333,6 +335,7 @@ debug_variables: $(E)echo ADT_OBJS: $(ADT_OBJS) $(E)echo GUM_OBJS: $(GUM_OBJS) $(E)echo GOBS_OBJS: $(GOBS_OBJS) + $(E)echo GACK_OBJS: $(GACK_OBJS) # $(E)echo TEST_CMPI_SRC: $(TEST_CMPI_SRC) $(E)echo TEST_DISKSIM_SRC: $(TEST_DISKSIM_SRC) # $(E)echo TEST_MPIRPC_SRC: $(TEST_MPIRPC_SRC) @@ -351,6 +354,7 @@ CMPI := lib/libcmpi.a MPIRPC := lib/libmpirpc.a CMPI_IO := lib/libcmpi-io.so GOBS = lib/libgobs.a +GACK = lib/libgack.a SKULLFS = lib/libskullfs.a ################################################################ @@ -413,6 +417,8 @@ mpirpc: $(MPIRPC) gobs: $(GOBS) +gack: $(GACK) + skullfs: $(SKULLFS) # Just like dir, but strip the slash off the end, to be pretty. @@ -451,7 +457,12 @@ $(GOBS): $(GOBS_OBJS) $(GUM_OBJS) $(E)$(INSTALL) -d lib $(E)ar rcs $(@) $(^) -$(SKULLFS): $(GOBS_OBJS) $(SKULLFS_OBJS) $(GUM_OBJS) +$(GACK): $(GACK_OBJS) $(GOBS_OBJS) $(SKULLFS_OBJS) $(GUM_OBJS) + $(Q) " AR $@" + $(E)$(INSTALL) -d lib + $(E)ar rcs $(@) $(^) + +$(SKULLFS): $(GACK_OBJS) $(GOBS_OBJS) $(SKULLFS_OBJS) $(GUM_OBJS) $(Q) " AR $@" $(E)$(INSTALL) -d lib $(E)ar rcs $(@) $(^) @@ -620,6 +631,7 @@ clean:: $(CMPI_PROGS) $(CMPI_CP_OBJS) splint.out \ $(GUM_OBJS) \ $(GOBS_OBJS) $(GOBS) src/gobs/launch.o \ + $(GACK_OBJS) $(GACK) \ $(SKULLFS_OBJS) \ $(ALL_GS_S) $(ALL_GS_I) $(ALL_GS_DUMMY) # $(E)find . -name "*.avg" -exec rm -fv \{\} \; diff --git a/code/configure.ac b/code/configure.ac index 4146c9c..555c5ec 100644 --- a/code/configure.ac +++ b/code/configure.ac @@ -881,6 +881,7 @@ src/adts/module.mk src/cmpi/module.mk src/cmpi-cp/module.mk src/cmpi-db/module.mk +src/gack/module.mk src/gobs/module.mk src/gobs/dense/module.mk src/gum/module.mk @@ -902,6 +903,7 @@ if test "x$ENABLE_TESTS" = "xyes" ; then test/cmpi/module.mk test/cmpi-io/module.mk test/driver/module.mk + test/gack/module.mk test/gobs/module.mk test/gum/module.mk test/gossip/module.mk diff --git a/code/src/gack/#_ascpx_blogin3.mcs.anl.gov_b_ahomes_awozniak_aproj_ags.git_acode_asrc_agack_agack.gs# b/code/src/gack/#_ascpx_blogin3.mcs.anl.gov_b_ahomes_awozniak_aproj_ags.git_acode_asrc_agack_agack.gs# new file mode 100644 index 0000000..232742a --- /dev/null +++ b/code/src/gack/#_ascpx_blogin3.mcs.anl.gov_b_ahomes_awozniak_aproj_ags.git_acode_asrc_agack_agack.gs# @@ -0,0 +1,3 @@ + +#include <gack.gsh> + diff --git a/code/src/gack/gack.gs b/code/src/gack/gack.gs new file mode 100644 index 0000000..cf31cba --- /dev/null +++ b/code/src/gack/gack.gs @@ -0,0 +1,56 @@ + +#include <gack.gsh> + +void +gack_init(gobs_impl impl, MPI_Comm comm) +{} + +gack_sack* +gack_allocate() +{ + gack_sack* result; + + int i,j,k,n; + gobs_id range; + gobs_id offset; + + result = malloc(sizeof(gack_sack)); + + n = gobs_size(); + + result->size = n; + result->id = malloc(n*sizeof(gobs_id)); + + offset = rand_lt(GOBS_LIMIT); + + range = GOBS_LIMIT/n; + j = -offset/range; + k = -j; + for (i = 0; i < n; i++) + { + result->id[k] = offset + range*j; + j++; + k = (k+1) % n; + } + + return result; +} + +gobs_id +gack_file() +{ + return rand_lt(100); +} + +void +gack_printf_sack(gack_sack* sack) +{ + int i; + + printf("sack: (%i) {", sack->size); + for (i = 0; i < sack->size-1; i++) + { + printf("%i ", sack->id[i]); + } + printf("%i}\n", sack->id[i]); +} diff --git a/code/src/gum/module.mk.in b/code/src/gack/module.mk.in similarity index 50% copy from code/src/gum/module.mk.in copy to code/src/gack/module.mk.in index 065d4a8..007623f 100644 --- a/code/src/gum/module.mk.in +++ b/code/src/gack/module.mk.in @@ -1,10 +1,10 @@ -# GUM +# GACK -DIR := src/gum +DIR := src/gack -GUM_GSSRC += $(shell cd @SRC_ABSOLUTE_TOP@; find $(DIR) -name "*.gs" ) -GUM_OBJS = $(patsubst %.gs, %.o, $(GUM_GSSRC)) +GACK_GSSRC += $(shell cd @SRC_ABSOLUTE_TOP@; find $(DIR) -name "*.gs" ) +GACK_OBJS := $(patsubst %.gs, %.o, $(GACK_GSSRC)) #src/gum/gum.o: src/gum/gum.gs src/include/gum.gsh $(GSCC) # $(Q) " GSCC $(@)" diff --git a/code/src/gobs/ait.gs b/code/src/gobs/ait.gs new file mode 100644 index 0000000..00cf71a --- /dev/null +++ b/code/src/gobs/ait.gs @@ -0,0 +1,72 @@ + +#include <ait.gsh> + +void +ait_create() +{ + gobs.ait_create(); +} + +ait_iterator* +ait_get_iterator() +{ + ait_iterator* result; + + result = gobs.ait_iterator(); + + return result; +} + +ait_entry* +ait_lookup(gobs_id id) +{ + return gobs.ait_lookup(id); +} + +__blocking int +handle_ait_fetch(gum_node caller, gum_msg* call) +{ + gum_msg response; + + ait_iterator* iterator; + ait_entry* entry; + + char* result; + char* p; + + result = malloc(gobs.ait_size()*100); + + iterator = ait_get_iterator(); + + p = result; + p += sprintf(p, "%i ", gobs.ait_size()); + while ((entry = gobs.ait_iterator_next(iterator)) != NULL) + { + p += sprintf(p, "%i ", entry->node.rank); + } + + response.unique = flip2(call->unique); + response.data = result; + response.length = strlen(result); + + gum_return(caller, &response); + + return 1; +} + +__blocking int +gobs_ait_pull(gum_node target) +{ + gum_msg* msg; + gum_msg* response; + + char args[8]; + + strcpy(args, ""); + msg = gum_msg_build(AIT_FETCH, args, 8); + gum_call(target, msg, &response); + + printf("gobs_ait_pull(): %s\n", response->data); + + return 1; +} diff --git a/code/src/gobs/dense/dense.gs b/code/src/gobs/dense/dense.gs index 9530513..6c65669 100644 --- a/code/src/gobs/dense/dense.gs +++ b/code/src/gobs/dense/dense.gs @@ -1,12 +1,91 @@ #include <gobs_dense.h> +ait_entry* gobs_dense_ait; +int gobs_dense_ait_size; + void gobs_dense_setup(MPI_Comm comm) { self.comm = comm; MPI_Comm_rank(self.comm, &self.rank); MPI_Comm_size(self.comm, &mpi_size); + + gobs_dense_ait_create(); + + gobs.ait_iterator = gobs_dense_get_iterator; + gobs.ait_size = gobs_dense_ait_get_size; + gobs.ait_lookup = gobs_dense_ait_lookup; + gobs.ait_iterator_next = gobs_dense_iterator_next; +} + +void +gobs_dense_ait_create() +{ + gobs_dense_ait = malloc(mpi_size*sizeof(ait_entry)); + gobs_dense_ait_size = mpi_size; +} + +int +gobs_dense_ait_get_size() +{ + return gobs_dense_ait_size; +} + +ait_entry* +gobs_dense_ait_lookup(gobs_id id) +{ + gum_node node; + + node = gobs_lookup(id); + + return &(gobs_dense_ait[node.rank]); +} + +ait_iterator* +gobs_dense_get_iterator() +{ + ait_iterator* result; + gobs_dense_iterator* dense_iterator; + ait_entry* table; + int i; + + result = malloc(sizeof(ait_iterator)); + + result->type = AIT_TYPE_DENSE; + + result->content = malloc(sizeof(gobs_dense_iterator)); + dense_iterator = result->content; + + dense_iterator->index = -1; + dense_iterator->table = malloc(mpi_size*sizeof(ait_entry)); + + table = dense_iterator->table; + for (i = 0; i < mpi_size; i++) + { + table[i].node.rank = i; + table[i].node.comm = self.comm; + table[i].status = AIT_STATUS_UP; + table[i].attrib = klist_create(); + } + + return result; +} + +ait_entry* +gobs_dense_iterator_next(ait_iterator* iterator) +{ + gobs_dense_iterator* dense_iterator; + + dense_iterator = iterator->content; + dense_iterator->index++; + + if (dense_iterator->index >= mpi_size) + { + return NULL; + } + + return &(dense_iterator->table[dense_iterator->index]); } /** @@ -67,6 +146,12 @@ gobs_lookup(gobs_id id) return node; } +int +gobs_size() +{ + return mpi_size; +} + __blocking int gobs_store(gum_node target, gobs_id id, char* data, int length) @@ -114,61 +199,6 @@ handle_store(gum_node caller, gum_msg* msg) return 1; } -__blocking int -gobs_write(gum_node target, gobs_id id, - char* data, int count, int offset) -{ - gum_msg* msg; - gum_msg* response; - - char args[64]; - - sprintf(args, "%i %i %i", id, count, offset); - msg = gum_msg_build(GOBS_WRITE, args, strlen(args)+1); - - gum_call(target, msg, &response); - - gs_mpi_send(data, count, MPI_CHAR, target.rank, - response->unique, target.comm); - - return 1; -} - -__blocking int -handle_write(gum_node caller, gum_msg* msg) -{ - MPI_Status status; - gum_msg response; - gobs_id id; - int count; - int offset; - char* object; - char* data; - - sscanf(msg->data, "%i %i %i", &id, &count, &offset); - - gossip_debug(MASK_STORAGE, "handle_write(%i,%i,%i)\n", - id, count, offset); - - response.unique = flip2(msg->unique); - response.data = malloc(1); - response.data[0] = '\0'; - response.length = 1; - - gum_return(caller, &response); - - data = malloc(GUM_MSG_MAX); - gs_mpi_recv(data, GUM_MSG_MAX, MPI_CHAR, caller.rank, - response.unique, caller.comm, &status); - - printdata("handle_write(): data: ", data, count); - - object = itable_search(gobs_cache, id); - memcpy(object+offset, data, count); - - return 1; -} - /** @param data OUT Must be allocated GUM_MSG_MAX bytes. */ @@ -219,65 +249,6 @@ handle_retrieve(gum_node caller, gum_msg* msg) } __blocking int -gobs_read(gum_node target, gobs_id id, - char* data, int count, int offset) -{ - MPI_Status status; - gum_msg* msg; - gum_msg* response; - - char args[64]; - - sprintf(args, "%i %i %i", id, count, offset); - msg = gum_msg_build(GOBS_READ, args, strlen(args)+1); - - gossip_debug(MASK_STORAGE, "gobs_read(%i,%i,%i)\n", - id, count, offset); - - gum_call(target, msg, &response); - - gs_mpi_recv(data, count, MPI_CHAR, target.rank, - response->unique, target.comm, &status); - - return 1; -} - -__blocking int -handle_read(gum_node caller, gum_msg* msg) -{ - gum_msg response; - gobs_id id; - int count; - int offset; - char* object; - char* data; - - sscanf(msg->data, "%i %i %i", &id, &count, &offset); - - gossip_debug(MASK_STORAGE, "handle_read(%i,%i,%i)\n", - id, count, offset); - - response.unique = flip2(msg->unique); - response.data = malloc(1); - response.data[0] = '\0'; - response.length = 1; - - gum_return(caller, &response); - - data = itable_search(gobs_cache, id); - - gs_mpi_send(data+offset, count, MPI_CHAR, caller.rank, - response.unique, caller.comm); - - // printdata("handle_read(): data: ", data, count); - - object = itable_search(gobs_cache, id); - memcpy(object+offset, data, count); - - return 1; -} - -__blocking int gobs_quit(gum_node target) { gum_msg* msg; diff --git a/code/src/gobs/gobs.gs b/code/src/gobs/gobs.gs index 60403fc..c07aed3 100644 --- a/code/src/gobs/gobs.gs +++ b/code/src/gobs/gobs.gs @@ -11,6 +11,9 @@ int mpi_size; struct itable* gobs_cache; +gobs_fns gobs; +gobs_id GOBS_LIMIT; + void gobs_init(gobs_impl impl, MPI_Comm comm) { @@ -22,7 +25,9 @@ gobs_init(gobs_impl impl, MPI_Comm comm) MPI_Comm_rank(gobs_comm, &mpi_rank); MPI_Comm_size(gobs_comm, &mpi_size); - gobs_cache = itable_create(10); + gobs_cache = itable_create(10); + + GOBS_LIMIT = INT_MAX; } /** @@ -107,7 +112,7 @@ gobs_response(MPI_Comm comm) } else if (idx == GOBS_ALLOCATE) { - handle_allocate(caller, &call); + // handle_allocate(caller, &call); } else if (idx == GOBS_STORE) { @@ -125,13 +130,16 @@ gobs_response(MPI_Comm comm) { handle_retrieve(caller, &call); } + // AIT OPERATIONS: + else if (idx == AIT_FETCH) + { + handle_ait_fetch(caller, &call); + } // FS OPERATIONS: - /* else if (idx == GOBS_OPEN) { handle_open(caller, &call); } - */ else if (idx == GOBS_MKFS) { handle_mkfs(caller, &call); @@ -166,13 +174,9 @@ gobs_response(MPI_Comm comm) { handle_link_file(caller, &call); } - else if (idx == GOBS_LINK_BLOB) - { - handle_link_blob(caller, &call); - } else if (idx == GOBS_BLOB_IDS) { - handle_blob_ids(caller, &call); + // handle_blob_ids(caller, &call); } else if (idx == GOBS_QUIT) { @@ -186,3 +190,135 @@ gobs_response(MPI_Comm comm) return 0; } + + +__blocking int +gobs_write(gum_node target, gobs_id id, + char* data, int count, int offset) +{ + gum_msg* msg; + gum_msg* response; + + char args[64]; + + sprintf(args, "%i %i %i", id, count, offset); + msg = gum_msg_build(GOBS_WRITE, args, strlen(args)+1); + + gum_call(target, msg, &response); + + gs_mpi_send(data, count, MPI_CHAR, target.rank, + response->unique, target.comm); + + return 1; +} + +__blocking int +handle_write(gum_node caller, gum_msg* msg) +{ + MPI_Status status; + gum_msg response; + gobs_id id; + int count; + int offset; + + skullfs_object* object; + skullfs_blob* blob; + char* tmp; + char* data; + + sscanf(msg->data, "%i %i %i", &id, &count, &offset); + + gossip_debug(MASK_STORAGE, "handle_write(%i,%i,%i)\n", + id, count, offset); + + response.unique = flip2(msg->unique); + response.data = malloc(1); + response.data[0] = '\0'; + response.length = 1; + + gum_return(caller, &response); + + data = malloc(GUM_MSG_MAX); + gs_mpi_recv(data, GUM_MSG_MAX, MPI_CHAR, caller.rank, + response.unique, caller.comm, &status); + + // printdata("handle_write(): data: ", data, count); + + object = itable_search(gobs_cache, id); + blob = object->contents; + + if (blob->size < offset+count) + { + tmp = realloc(blob->data, offset+count); + blob->data = tmp; + blob->size = offset+count; + } + + memcpy(blob->data+offset, data, count); + + return 1; +} + +__blocking int +gobs_read(gum_node target, gobs_id id, + char* data, int count, int offset) +{ + MPI_Status status; + gum_msg* msg; + gum_msg* response; + + char args[64]; + + sprintf(args, "%i %i %i", id, count, offset); + msg = gum_msg_build(GOBS_READ, args, strlen(args)+1); + + gossip_debug(MASK_STORAGE, "gobs_read(%i,%i,%i)\n", + id, count, offset); + + gum_call(target, msg, &response); + + gs_mpi_recv(data, count, MPI_CHAR, target.rank, + response->unique, target.comm, &status); + + return 1; +} + +__blocking int +handle_read(gum_node caller, gum_msg* msg) +{ + gum_msg response; + gobs_id id; + + int count; + int offset; + + skullfs_object* object; + skullfs_blob* blob; + + char* data; + + sscanf(msg->data, "%i %i %i", &id, &count, &offset); + + gossip_debug(MASK_STORAGE, "handle_read(%i,%i,%i)\n", + id, count, offset); + + response.unique = flip2(msg->unique); + response.data = malloc(1); + response.data[0] = '\0'; + response.length = 1; + + gum_return(caller, &response); + + object = itable_search(gobs_cache, id); + blob = object->contents; + data = blob->data; + + gs_mpi_send(data+offset, count, MPI_CHAR, caller.rank, + response.unique, caller.comm); + + gossip_do(MASK_FS, printdata("handle_read(): data: ", + data, count)); + + return 1; +} + diff --git a/code/src/gobs/interpreter.gs b/code/src/gobs/interpreter.gs deleted file mode 100644 index 996c5d2..0000000 --- a/code/src/gobs/interpreter.gs +++ /dev/null @@ -1,8 +0,0 @@ - -#include <interpreter.gsh> - -int -handle_open(gum_node caller, gum_msg* call) -{ - return 0; -} diff --git a/code/src/gobs/launch.gs b/code/src/gobs/launch.gs index 4cf37fb..fb04666 100644 --- a/code/src/gobs/launch.gs +++ b/code/src/gobs/launch.gs @@ -13,6 +13,8 @@ int gobs_layout_clients; char dmalloc_mpi_logpath[128]; +bool gobs_using_gdb; + gs_ret_t bootstrap_post(void (f)(void*,int), void*, gs_hints_t, gs_context_t, gs_op_id_t*); @@ -65,7 +67,7 @@ gdb_startup(void) fflush(stdout); - // if (mpi_rank == 0) + if (mpi_rank == 0) while (!gdb_wait); } diff --git a/code/src/gobs/module.mk.in b/code/src/gobs/module.mk.in index 8ac30b7..42cd261 100644 --- a/code/src/gobs/module.mk.in +++ b/code/src/gobs/module.mk.in @@ -8,11 +8,11 @@ GOBS_ADTS += src/adts/hashtable.c GOBS_ADTS += src/adts/ilist.c GOBS_ADTS += src/adts/klist.c -GOBS_GSSRC := src/gobs/client.gs src/gobs/storage.gs src/skullfs/skullfs.o src/gobs/dense/dense.gs src/gobs/gobs.gs -# src/gobs/table.gs +GOBS_GSSRC := src/gobs/client.gs src/gobs/storage.gs src/gobs/ait.gs src/skullfs/skullfs.o src/gobs/dense/dense.gs src/gobs/gobs.gs # $(shell cd @SRC_ABSOLUTE_TOP@; find $(DIR) -name "*.gs" ) -GOBS_OBJS := $(patsubst %.gs, %.o, $(GOBS_GSSRC)) $(patsubst %.c, %.o, $(GOBS_ADTS)) src/mpi_tools/mpi_tools.o src/common/gossip/gossip.o +# SKULLFS and GACK only necessary until we get function pointers working +GOBS_OBJS := $(patsubst %.gs, %.o, $(GOBS_GSSRC)) $(patsubst %.c, %.o, $(GOBS_ADTS)) src/mpi_tools/mpi_tools.o src/common/gossip/gossip.o src/skullfs/skullfs.o src/skullfs/handlers.o src/skullfs/rpcs.o src/gack/gack.o # $(GUM_OBJS) diff --git a/code/src/include/ait.gsh b/code/src/include/ait.gsh new file mode 100644 index 0000000..80b3080 --- /dev/null +++ b/code/src/include/ait.gsh @@ -0,0 +1,12 @@ + +#ifndef AIT_GSH +#define AIT_GSH + +#include <ait_types.gsh> +#include <gobs.gsh> + +void gobs_neighbor_down(gum_node node); + +void gobs_neighbor_up(gum_node node); + +#endif diff --git a/code/src/include/ait_types.gsh b/code/src/include/ait_types.gsh new file mode 100644 index 0000000..0109b47 --- /dev/null +++ b/code/src/include/ait_types.gsh @@ -0,0 +1,33 @@ + +#ifndef AIT_TYPES_GSH +#define AIT_TYPES_GSH + +#include <gum.gsh> + +typedef enum +{ + AIT_STATUS_PROTO, + AIT_STATUS_UP, + AIT_STATUS_DOWN +} ait_status; + +typedef enum +{ + AIT_TYPE_DENSE, + AIT_TYPE_KDA +} ait_type; + +typedef struct +{ + gum_node node; + ait_status status; + struct klist* attrib; +} ait_entry; + +typedef struct +{ + ait_type type; + void* content; +} ait_iterator; + +#endif diff --git a/code/src/include/gack.gsh b/code/src/include/gack.gsh new file mode 100644 index 0000000..486f7de --- /dev/null +++ b/code/src/include/gack.gsh @@ -0,0 +1,29 @@ + +/** + GACK: Grayskull Allocation Controller +*/ + +#ifndef GACK_GSH +#define GACK_GSH + +#include <stdbool.h> +#include <stdio.h> +#include <unistd.h> + +#include <mpi.h> + +#include <include/gs.h> +#include <resources/mpi/gs-mpi.gsh> + +#include <gack_types.gsh> +#include <gobs.gsh> + +void gack_init(gobs_impl impl, MPI_Comm comm); + +gobs_id gack_file(); + +gack_sack* gack_allocate(); + +void gack_printf_sack(gack_sack* sack); + +#endif diff --git a/code/src/include/gack_types.gsh b/code/src/include/gack_types.gsh new file mode 100644 index 0000000..5964c6e --- /dev/null +++ b/code/src/include/gack_types.gsh @@ -0,0 +1,13 @@ + +#ifndef GACK_TYPES_GSH +#define GACK_TYPES_GSH + +#include <gobs_types.gsh> + +typedef struct +{ + int size; + gobs_id* id; +} gack_sack; + +#endif diff --git a/code/src/include/gobs.gsh b/code/src/include/gobs.gsh index a5fc0d9..59b6bcf 100644 --- a/code/src/include/gobs.gsh +++ b/code/src/include/gobs.gsh @@ -6,6 +6,7 @@ #ifndef GOBS_GSH #define GOBS_GSH +#include <limits.h> #include <stdbool.h> #include <stdio.h> #include <unistd.h> @@ -16,21 +17,59 @@ #include <resources/mpi/gs-mpi.gsh> #include <gobs_types.gsh> +#include <ait.gsh> #include <skullfs.gsh> #include <skullfs_handlers.gsh> // #warning GOBS.GSH -bool gobs_using_gdb; +// extern bool gobs_using_gdb; +extern gobs_id GOBS_LIMIT; +extern int mpi_rank; +extern bool gobs_running; +extern gum_node self; +extern int mpi_size; +// extern gobs_impl gobs_current_impl; + +//// Client section: + +__blocking int gobs_query(gum_node target, gobs_id id, + gum_node* node); + +__blocking int gobs_store(gum_node target, gobs_id id, + char* data, int length); + +__blocking int gobs_write(gum_node node, gobs_id id, + char* data, int count, int offset); + +__blocking int gobs_retrieve(gum_node target, gobs_id id, + char* data); + +__blocking int gobs_read(gum_node node, gobs_id id, + char* data, int count, int offset); + +__blocking int gobs_client_code(); + +gum_node gobs_lookup(gobs_id id); + +__blocking int gobs_ait_pull(gum_node node); + +//// Server section: -/* typedef struct { void (*setup)(MPI_Comm comm); gum_node (*lookup)(gobs_id id); - gum_node (*query)(gum_node target, gobs_id id); + gum_node (*query)(gum_node target, gobs_id id); + + void (*ait_create)(); + ait_iterator* (*ait_iterator)(void); + ait_entry* (*ait_iterator_next)(ait_iterator*); + int (*ait_size)(); + ait_entry* (*ait_lookup)(gobs_id id); } gobs_fns; -*/ + +extern gobs_fns gobs; void gobs_init(gobs_impl impl, MPI_Comm comm); @@ -46,25 +85,6 @@ __blocking int gobs_ping(gum_node target); __blocking int gobs_response(MPI_Comm comm); -gum_node gobs_lookup(gobs_id id); - -// #warning GOBS_QUERY - -__blocking int gobs_query(gum_node target, gobs_id id, - gum_node* node); - -__blocking int gobs_store(gum_node target, gobs_id id, - char* data, int length); - -__blocking int gobs_write(gum_node node, gobs_id blob_id, - char* data, int count, int offset); - -__blocking int gobs_retrieve(gum_node target, gobs_id id, - char* data); - -__blocking int gobs_read(gum_node node, gobs_id blob_id, - char* data, int count, int offset); - __blocking int gobs_quit(gum_node target); __blocking int handle_query(gum_node caller, gum_msg* call); @@ -79,9 +99,9 @@ __blocking int handle_read(gum_node caller, gum_msg* call); __blocking int handle_lookup(gum_node caller, gum_msg* call); -__blocking int handle_quit(gum_node caller, gum_msg* call); +__blocking int handle_ait_fetch(gum_node caller, gum_msg* call); -__blocking int gobs_client_code(); +__blocking int handle_quit(gum_node caller, gum_msg* call); __blocking int gobs_all_quit(); diff --git a/code/src/include/gobs_dense.h b/code/src/include/gobs_dense.h index 7a84818..4d0e253 100644 --- a/code/src/include/gobs_dense.h +++ b/code/src/include/gobs_dense.h @@ -4,11 +4,29 @@ #include <gobs.gsh> +typedef struct +{ + int index; + ait_entry* table; +} gobs_dense_iterator; + // extern gobs_fns gobs_dense_impl; +extern ait_entry* gobs_dense_ait; +extern int gobs_dense_ait_size; void gobs_dense_setup(MPI_Comm comm); +void gobs_dense_ait_create(); + +int gobs_dense_ait_get_size(); + +ait_iterator* gobs_dense_get_iterator(); + +ait_entry* gobs_dense_iterator_next(ait_iterator* iterator); + +ait_entry* gobs_dense_ait_lookup(gobs_id id); + /* gum_node gobs_dense_lookup(gobs_id id); diff --git a/code/src/include/gobs_types.gsh b/code/src/include/gobs_types.gsh index ac59c73..1e3a4b1 100644 --- a/code/src/include/gobs_types.gsh +++ b/code/src/include/gobs_types.gsh @@ -41,13 +41,11 @@ typedef enum GOBS_LINK_FILE, // 15 GOBS_LINK_BLOB, GOBS_BLOB_IDS, - GOBS_QUIT -} gobs_fns; -extern int mpi_rank; -extern bool gobs_running; -extern gum_node self; -extern int mpi_size; -extern gobs_fns gobs; + AIT_FETCH, + AIT_HASH, + + GOBS_QUIT +} gobs_code; #endif diff --git a/code/src/include/gum.gsh b/code/src/include/gum.gsh index 18e878f..bec5ee1 100644 --- a/code/src/include/gum.gsh +++ b/code/src/include/gum.gsh @@ -72,15 +72,15 @@ void gum_register(char* name, gum_proc procedure); gum_proc_idx gum_procedure_create(char* name); void gum_pack(gum_msg* msg); -int gum_call(gum_node target, gum_msg* msg, gum_msg** response); +// int gum_call(gum_node target, gum_msg* msg, gum_msg** response); __blocking int gum_call(gum_node target, gum_msg* msg, gum_msg** response); __blocking int gum_response(); -int gum_recv(gum_node target, int tag, gum_proc_idx* idx, - int* unique, int* length, char* data); +/* int gum_recv(gum_node target, int tag, gum_proc_idx* idx, + int* unique, int* length, char* data); */ __blocking int gum_recv(gum_node target, int tag, gum_proc_idx* idx, int* unique, int* length, char* data); diff --git a/code/src/include/interpreter.gsh b/code/src/include/interpreter.gsh deleted file mode 100644 index a45d124..0000000 --- a/code/src/include/interpreter.gsh +++ /dev/null @@ -1,32 +0,0 @@ - -/** - INTERPRETER: Translate FS operations into GOBS operations. -*/ - -#ifndef INTERPRETER_GSH -#define INTERPRETER_GSH - -#include <linux/limits.h> - -#include <gobs.gsh> - -#define SKULLFS_BLOB_SIZE 4 - -typedef enum -{ - SKULLFS_DIRECTORY, - SKULLFS_FILE, - SKULLFS_BLOB -} skullfs_object_type; - -typedef struct -{ - skullfs_object_type type; - void* contents; -} skullfs_object; - -int skullfs_split_path(char* path, char** ptrs, int* lengths); - -int handle_open(gum_node caller, gum_msg* call); - -#endif diff --git a/code/src/include/skullfs.gsh b/code/src/include/skullfs.gsh index e040019..e2d5ec4 100644 --- a/code/src/include/skullfs.gsh +++ b/code/src/include/skullfs.gsh @@ -8,7 +8,7 @@ #include <linux/limits.h> -#include <gobs.gsh> +#include <gack.gsh> #include <skullfs_rpcs.gsh> #define SKULLFS_BLOB_SIZE 4 @@ -26,6 +26,17 @@ typedef struct void* contents; } skullfs_object; +typedef struct +{ + gack_sack* sack; +} skullfs_file; + +typedef struct +{ + long size; + char* data; +} skullfs_blob; + int skullfs_split_path(char* path, char** ptrs, int* lengths); int skullfs_serialize_directory(int count, char** names, int* ids, @@ -44,7 +55,7 @@ int skullfs_link_blob(gobs_id file_id, gobs_id blob_id, int skullfs_create_blob(gobs_id blob_id); -int skullfs_create_file(gobs_id file_id); +int skullfs_create_file(gobs_id file_id, gack_sack* sack); int skullfs_link_file(gobs_id directory_id, gobs_id file_id, char* name); diff --git a/code/src/include/skullfs_client.gsh b/code/src/include/skullfs_client.gsh index aeec54f..77af776 100644 --- a/code/src/include/skullfs_client.gsh +++ b/code/src/include/skullfs_client.gsh @@ -5,9 +5,16 @@ #include <linux/limits.h> #include <gobs.gsh> +#include <gack_types.gsh> // __blocking gobs_id skull_lookup(gum_node target, char* path); +typedef struct +{ + gobs_id id; + gack_sack sack; +} skullfs_fd; + __blocking int skullfs_mkfs(gum_node target, gobs_id* root_id); __blocking int skullfs_mkdir(gum_node target, @@ -20,10 +27,13 @@ __blocking int skullfs_ls(gum_node target, gobs_id directory_id, __blocking int skullfs_create(gum_node target, gobs_id directory_id, char* name, gobs_id* file_id); -__blocking int skullfs_pwrite(gum_node target, gobs_id file, +__blocking int skullfs_open(gum_node target, gobs_id file, + skullfs_fd* fd); + +__blocking int skullfs_pwrite(gum_node target, skullfs_fd* file, void* data, int count, int offset); -__blocking int skullfs_pread(gum_node target, gobs_id file, +__blocking int skullfs_pread(gum_node target, skullfs_fd* file, void* data, int count, int offset); __blocking int skullfs_fallocate(gum_node target, gobs_id file_id, diff --git a/code/src/include/skullfs_handlers.gsh b/code/src/include/skullfs_handlers.gsh index 7ec3db8..f4458ff 100644 --- a/code/src/include/skullfs_handlers.gsh +++ b/code/src/include/skullfs_handlers.gsh @@ -32,4 +32,6 @@ __blocking int handle_blob_ids(gum_node caller, gum_msg* call); __blocking int handle_allocate(gum_node caller, gum_msg* call); +__blocking int handle_open(gum_node caller, gum_msg* call); + #endif diff --git a/code/src/include/skullfs_rpcs.gsh b/code/src/include/skullfs_rpcs.gsh index 2ae6337..f2eb81a 100644 --- a/code/src/include/skullfs_rpcs.gsh +++ b/code/src/include/skullfs_rpcs.gsh @@ -10,9 +10,9 @@ __blocking int rpc_create_blob(gobs_location* blob); -__blocking int rpc_create_file(gobs_location* file); +__blocking int rpc_create_file(gobs_location* file, gack_sack* sack); -__blocking int rpc_link_blob(gobs_location file, gobs_location blob); +// __blocking int rpc_link_blob(gobs_location file, gobs_location blob); __blocking int rpc_link_file(gobs_location directory, gobs_location file, char* filename); diff --git a/code/src/skullfs/client.gs b/code/src/skullfs/client.gs index b98f55b..d5550c7 100644 --- a/code/src/skullfs/client.gs +++ b/code/src/skullfs/client.gs @@ -15,33 +15,10 @@ skull_init(MPI_Comm comm, struct ilist* contacts) } */ -/* -skull_file* -skull_open(char* name) -{ - skull_file* result; - int rank; - gum_node target; - gum_msg* msg; - gum_msg* response; - - result = malloc(sizeof(skull_file)); - strcpy(result->name, name); - - target.rank = ilist_random(skull_contacts); - target.comm = skull_comm; - msg = gum_msg_build(GOBS_OPEN, name, strlen(name)+1); - gum_call(target, msg, &response); - sscanf(response->data, "%i", result->id); - - return result; -} -*/ - /** @param root_id OUT The gobs_id of the root directory object. */ -__blocking gobs_id +__blocking int skullfs_mkfs(gum_node target, gobs_id* root_id) { gobs_id result; @@ -159,13 +136,49 @@ skullfs_create(gum_node target, gobs_id directory_id, char* name, } __blocking int -skullfs_pwrite(gum_node target, gobs_id file_id, +skullfs_open(gum_node target, gobs_id file, skullfs_fd* fd) +{ + gum_node recipient; + gum_msg* msg; + gum_msg* response; + + char args[32]; + char* p; + int i,n; + + sprintf(args, "%i", file); + + gobs_query(target, file, &recipient); + msg = gum_msg_build(GOBS_OPEN, args, strlen(args)+1); + gum_call(recipient, msg, &response); + + p = response->data; + sscanf(p, "%i %n", &(fd->sack.size), &n); + p += n; + + fd->sack.id = malloc(fd->sack.size * sizeof(gobs_id)); + for (i = 0; i < fd->sack.size; i++) + { + sscanf(p, "%i %n", &(fd->sack.id[i]), &n); + p += n; + } + + return 1; + +} + +__blocking int +skullfs_pwrite(gum_node target, skullfs_fd* fd, void* data, int count, int offset) { + gack_sack sack; + int current; + int wraps; + // Number of first blob: int first; // Number of blobs: - int blobs; + int total; // Blob number: int i; // Helper indices into data: @@ -173,32 +186,39 @@ skullfs_pwrite(gum_node target, gobs_id file_id, // Moving pointer into data: void* p; - gobs_id* blob_ids; - - first = offset/SKULLFS_BLOB_SIZE; - blobs = count/SKULLFS_BLOB_SIZE + 1; + sack = fd->sack; - blob_ids = malloc(blobs*sizeof(gobs_id)); + first = (offset/SKULLFS_BLOB_SIZE) % sack.size; + wraps = offset/(SKULLFS_BLOB_SIZE*sack.size); + total = count/SKULLFS_BLOB_SIZE + 1; - skullfs_fallocate(target, file_id, first, blobs, blob_ids); - p = data; - + // Write first partial blob... + current = first; r = offset % SKULLFS_BLOB_SIZE; l = SKULLFS_BLOB_SIZE-r; - skullfs_pwrite_blob(target, blob_ids[0], p, l, r); + skullfs_pwrite_blob(target, sack.id[current], p, l, r); p += l; - // Write whole blobs: - for (i = 1; i < blobs-1; i++) + // Write whole blobs: + for (i = 1; i < total-1; i++) { - skullfs_pwrite_blob(target, blob_ids[i], p, SKULLFS_BLOB_SIZE, 0); + current = current+1 % sack.size; + if (current == 0) + wraps++; + skullfs_pwrite_blob(target, sack.id[current], p, + SKULLFS_BLOB_SIZE, wraps*SKULLFS_BLOB_SIZE); + p += SKULLFS_BLOB_SIZE; } // Write last partial blob... + current = current+1 % sack.size; + if (current == 0) + wraps++; l = count % SKULLFS_BLOB_SIZE; - skullfs_pwrite_blob(target, blob_ids[i], p, l, 0); + skullfs_pwrite_blob(target, sack.id[current], p, l, + wraps*SKULLFS_BLOB_SIZE); return 1; } @@ -208,6 +228,7 @@ skullfs_pwrite(gum_node target, gobs_id file_id, Create blobs if necessary. @param blobs_ids OUT The resulting blob ids. */ +/* __blocking int skullfs_fallocate(gum_node target, gobs_id file_id, int first, int blobs, gobs_id* blob_ids) @@ -239,11 +260,13 @@ skullfs_fallocate(gum_node target, gobs_id file_id, return 1; } +*/ /** Find all the blobs for this file. @param blobs_ids OUT The resulting blob ids. */ +/* __blocking int skullfs_blob_ids(gum_node target, gobs_id file_id, int first, int blobs, gobs_id* blob_ids) @@ -278,6 +301,7 @@ skullfs_blob_ids(gum_node target, gobs_id file_id, return 1; } +*/ __blocking int skullfs_pwrite_blob(gum_node target, gobs_id blob_id, @@ -296,13 +320,17 @@ skullfs_pwrite_blob(gum_node target, gobs_id blob_id, } __blocking int -skullfs_pread(gum_node target, gobs_id file_id, +skullfs_pread(gum_node target, skullfs_fd* fd, void* data, int count, int offset) { + gack_sack sack; + int current; + int wraps; + // Number of first blob: int first; // Number of blobs: - int blobs; + int total; // Blob number: int i; // Helper indices into data: @@ -310,33 +338,39 @@ skullfs_pread(gum_node target, gobs_id file_id, // Moving pointer into data: void* p; - gobs_id* blob_ids; - - first = offset/SKULLFS_BLOB_SIZE; - blobs = count/SKULLFS_BLOB_SIZE + 1; + sack = fd->sack; + + first = (offset/SKULLFS_BLOB_SIZE) % sack.size; + wraps = offset/(SKULLFS_BLOB_SIZE*sack.size); + total = count/SKULLFS_BLOB_SIZE + 1; - blob_ids = malloc(blobs*sizeof(gobs_id)); - - skullfs_blob_ids(target, file_id, first, blobs, blob_ids); - p = data; - - // Write first partial object... + + // Read first partial blob... + current = first; r = offset % SKULLFS_BLOB_SIZE; l = SKULLFS_BLOB_SIZE-r; - skullfs_pread_blob(target, blob_ids[0], p, l, r); + skullfs_pread_blob(target, sack.id[current], p, l, r); p += l; - // Write whole blobs: - for (i = first+1; i < blobs-1; i++) + // Read whole blobs: + for (i = first+1; i < total-1; i++) { - skullfs_pread_blob(target, blob_ids[i], p, SKULLFS_BLOB_SIZE, 0); + current = current+1 % sack.size; + if (current == 0) + wraps++; + skullfs_pread_blob(target, sack.id[current], p, + SKULLFS_BLOB_SIZE, wraps*SKULLFS_BLOB_SIZE); p += SKULLFS_BLOB_SIZE; } // Write last partial blob: + current = current+1 % sack.size; + if (current == 0) + wraps++; l = count % SKULLFS_BLOB_SIZE; - skullfs_pread_blob(target, blob_ids[i], p, l, 0); + skullfs_pread_blob(target, sack.id[current], p, l, + wraps*SKULLFS_BLOB_SIZE); return 1; } diff --git a/code/src/skullfs/handlers.gs b/code/src/skullfs/handlers.gs index fe9480e..f4cb202 100644 --- a/code/src/skullfs/handlers.gs +++ b/code/src/skullfs/handlers.gs @@ -156,14 +156,29 @@ handle_link_file(gum_node caller, gum_msg* call) __blocking int handle_create_file(gum_node caller, gum_msg* call) { - gum_msg response; - gobs_id file_id; + gum_msg response; + gobs_id file_id; + gack_sack* sack; - printf("handle_create_file()\n"); + int i,n; + char* p; + p = call->data; - sscanf(call->data, "%i", &file_id); + printf("handle_create_file(%s)\n", call->data); + p = call->data; - skullfs_create_file(file_id); + sack = malloc(sizeof(gack_sack)); + sscanf(p, "%i %i %n", &file_id, &(sack->size), &n); + p += n; + + sack->id = malloc(sack->size * sizeof(gobs_id)); + for (i = 0; i < n; i++) + { + sscanf(p, "%i %n", &(sack->id[i]), &n); + p += n; + } + + skullfs_create_file(file_id, sack); response.unique = flip2(call->unique); response.data = NULL; @@ -174,20 +189,22 @@ handle_create_file(gum_node caller, gum_msg* call) return 1; } +/* __blocking int -handle_link_blob(gum_node caller, gum_msg* call) +handle_link_blobs(gum_node caller, gum_msg* call) { gum_msg response; gobs_id file_id; + gack_sack sack; int blob_number; gobs_id blob_id; - - printf("handle_link_blob():\n"); + int n; + char* p; - sscanf(call->data, "%i %i %i", &file_id, &blob_id, &blob_number); + printf("handle_link_blobs():\n"); - skullfs_link_blob(file_id, blob_id, blob_number); + skullfs_link_blobs(file_id, &sack); response.unique = flip2(call->unique); response.data = NULL; @@ -197,6 +214,7 @@ handle_link_blob(gum_node caller, gum_msg* call) return 1; } +*/ __blocking int handle_create_blob(gum_node caller, gum_msg* call) @@ -204,15 +222,11 @@ handle_create_blob(gum_node caller, gum_msg* call) gum_msg response; gobs_id blob_id; - skullfs_object* blob; - gossip_debug(MASK_FS, "handle_create_blob(): \n"); - blob = skullfs_alloc_blob(); - sscanf(call->data, "%i", &blob_id); - - itable_add(gobs_cache, blob_id, blob); + + skullfs_create_blob(blob_id); response.unique = flip2(call->unique); response.data = malloc(1); @@ -224,6 +238,7 @@ handle_create_blob(gum_node caller, gum_msg* call) return 1; } +/* __blocking int handle_allocate(gum_node caller, gum_msg* call) { @@ -257,7 +272,9 @@ handle_allocate(gum_node caller, gum_msg* call) return 1; } +*/ +/* __blocking int handle_blob_ids(gum_node caller, gum_msg* call) { @@ -291,3 +308,41 @@ handle_blob_ids(gum_node caller, gum_msg* call) return 1; } +*/ + +__blocking int +handle_open(gum_node caller, gum_msg* call) +{ + gum_msg response; + gobs_id file_id; + + skullfs_object* object; + skullfs_file* file; + gack_sack* sack; + + int i; + char* p; + + gossip_debug(MASK_FS, "handle_open(): \n"); + + sscanf(call->data, "%i", &file_id); + + object = itable_search(gobs_cache, file_id); + file = object->contents; + sack = file->sack; + + response.unique = flip2(call->unique); + response.data = malloc(sack->size * 16); + + p = response.data; + p += sprintf(p, "%i ", sack->size); + for (i = 0; i < sack->size; i++) + { + p += sprintf(p, "%i ", sack->id[i]); + } + response.length = strlen(response.data)+1; + + gum_return(caller, &response); + + return 1; +} diff --git a/code/src/skullfs/rpcs.gs b/code/src/skullfs/rpcs.gs index c4c4a15..b1222d6 100644 --- a/code/src/skullfs/rpcs.gs +++ b/code/src/skullfs/rpcs.gs @@ -9,7 +9,6 @@ rpc_create_blob(gobs_location* blob) char args[32]; - blob->id = rand_lt(1000); gossip_debug(MASK_FS, "rpc_create_blob(%i): \n", blob->id); blob->node = gobs_lookup(blob->id); @@ -30,24 +29,32 @@ rpc_create_blob(gobs_location* blob) } __blocking int -rpc_create_file(gobs_location* file) +rpc_create_file(gobs_location* file, gack_sack* sack) { gum_msg file_msg; gum_msg* response; - char args[32]; + char* args; + char* p; + int i; - file->id = rand_lt(100); + args = malloc(16*sack->size+32); + p = args; + + file->id = gack_file(); file->node = gobs_lookup(file->id); if (file->node.comm == self.comm && file->node.rank == self.rank) { - skullfs_create_file(file->id); + skullfs_create_file(file->id, sack); } else { - sprintf(args, "%i", file->id); + p += sprintf(p, "%i %i ", file->id, sack->size); + for (i = 0; i < sack->size; i++) + p += sprintf(p, "%i ", sack->id[i]); + gum_msg_init(GOBS_CREATE_FILE, args, strlen(args)+1, &file_msg); gum_call(file->node, &file_msg, &response); } @@ -56,29 +63,6 @@ rpc_create_file(gobs_location* file) } __blocking int -rpc_link_blob(gobs_location file, gobs_location blob) -{ - gum_msg link_msg; - gum_msg* response; - - char args[32]; - - if (file.node.comm == self.comm && - file.node.rank == self.rank) - { - skullfs_link_blob(file.id, blob.id, 0); - } - else - { - sprintf(args, "%i %i %i", file.id, blob.id, 0); - gum_msg_init(GOBS_LINK_BLOB, args, strlen(args)+1, &link_msg); - gum_call(file.node, &link_msg, &response); - } - - return 1; -} - -__blocking int rpc_link_file(gobs_location directory, gobs_location file, char* filename) { diff --git a/code/src/skullfs/skullfs.gs b/code/src/skullfs/skullfs.gs index 13a7e7f..5c6b011 100644 --- a/code/src/skullfs/skullfs.gs +++ b/code/src/skullfs/skullfs.gs @@ -69,10 +69,14 @@ skullfs_object* skullfs_alloc_file() { skullfs_object* result; + skullfs_file* file; result = malloc(sizeof(skullfs_object)); result->type = SKULLFS_FILE; - result->contents = itable_create(10); + result->contents = malloc(sizeof(skullfs_file)); + + file = result->contents; + file->sack = NULL; return result; } @@ -81,10 +85,14 @@ skullfs_object* skullfs_alloc_blob() { skullfs_object* result; + skullfs_blob* blob; result = malloc(sizeof(skullfs_object)); result->type = SKULLFS_BLOB; - result->contents = malloc(SKULLFS_BLOB_SIZE); + result->contents = malloc(sizeof(skullfs_blob)); + blob = result->contents; + blob->size = 0; + blob->data = NULL; return result; } @@ -152,14 +160,14 @@ skullfs_list(gobs_id directory_id, char*** names, int** ids) return contents->size; } +/* int -skullfs_link_blob(gobs_id file_id, gobs_id blob_id, int blob_number) +skullfs_link_blobs(gobs_id file_id, gack_sack* sack) { skullfs_object* file; gobs_id* blob_space; - blob_space = malloc(sizeof(gobs_id)); - *blob_space = blob_id; + blob_space = malloc(sack->size * sizeof(gobs_id)); gossip_debug(MASK_FS, "skullfs_link_blob(%i,%i,%i)...\n", file_id, blob_id, blob_number); @@ -169,6 +177,7 @@ skullfs_link_blob(gobs_id file_id, gobs_id blob_id, int blob_number) return 1; } +*/ int skullfs_create_blob(gobs_id blob_id) @@ -184,13 +193,19 @@ skullfs_create_blob(gobs_id blob_id) } int -skullfs_create_file(gobs_id file_id) +skullfs_create_file(gobs_id file_id, gack_sack* sack) { - skullfs_object* file; + skullfs_object* object; + skullfs_file* file; - file = skullfs_alloc_file(); - itable_add(gobs_cache, file_id, file); + object = skullfs_alloc_file(); + file = object->contents; + file->sack = sack; + gossip_debug(MASK_FS, "skullfs_create_file(%i)\n", file_id); + + itable_add(gobs_cache, file_id, object); + return 1; } @@ -210,7 +225,6 @@ skullfs_link_file(gobs_id directory_id, gobs_id file_id, char* name) return 1; } - /** Create file. Remote nodes are contacted to create the file, the first blob, @@ -223,24 +237,27 @@ skullfs_make_file(gobs_id directory_id, char* filename, gobs_id* file_id) { gobs_location file; + gack_sack* sack; gobs_location blob; gobs_location directory; + int i; + directory.id = directory_id; + sack = gack_allocate(); + gossip_debug(MASK_FS, "skullfs_make_file(): \n"); - rpc_create_blob(&blob); - - gossip_debug(MASK_FS, "created blob: %i\n", blob.id); + for (i = 0; i < sack->size; i++) + { + blob.id = sack->id[i]; + rpc_create_blob(&blob); + } - rpc_create_file(&file); + rpc_create_file(&file, sack); gossip_debug(MASK_FS, "created file\n"); - - rpc_link_blob(file, blob); - - gossip_debug(MASK_FS, "linked blob\n"); directory.node = gobs_lookup(directory.id); rpc_link_file(directory, file, filename); @@ -252,10 +269,10 @@ skullfs_make_file(gobs_id directory_id, char* filename, return 1; } -/** +/* Return the list relevant blob ids. If more were requested, create them. -*/ + __blocking int skullfs_ensure_blobs(gobs_id file_id, int first, int count, gobs_id* blob_ids) @@ -298,9 +315,10 @@ skullfs_ensure_blobs(gobs_id file_id, int first, int count, return 1; } +*/ /** - Return the list relevant blob ids. + Return the list of relevant blob ids. If more were requested, return 0s for those blob ids. @param blob_ids OUT */ diff --git a/code/test/adts/test07.c b/code/test/adts/test07.c new file mode 100644 index 0000000..daabb02 --- /dev/null +++ b/code/test/adts/test07.c @@ -0,0 +1,43 @@ + +#include <xtree.h> + +int +main() +{ + struct xtree* tree = xtree_create(); + + xtree_printf(tree); + + xtree_add(tree, 2, NULL); + xtree_printf(tree); + + xtree_add(tree, 4, NULL); + printf("after 4\n"); + xtree_printf(tree); + + xtree_add(tree, 8, NULL); + printf("after 8\n"); + xtree_printf(tree); + + xtree_add(tree, 8000, NULL); + printf("after 8000\n"); + xtree_printf(tree); + + xtree_add(tree, 6, NULL); + printf("after 6\n"); + xtree_printf(tree); + + xtree_add(tree, 8001, NULL); + printf("after 8001\n"); + xtree_printf(tree); + + struct inlist* nodes = xtree_query(tree, 8008, 2); + inlist_printf(nodes); + + void* d = xtree_search(tree, 8000); + printf("search: %p\n", d); + + printf("ok\n"); + + return 0; +} diff --git a/code/test/common/gdb_wait_loop.c b/code/test/common/gdb_wait_loop.c new file mode 100644 index 0000000..6c06f66 --- /dev/null +++ b/code/test/common/gdb_wait_loop.c @@ -0,0 +1,11 @@ + +void +gdb_wait_loop() +{ + int v = 0; + + pid_t pid = getpid(); + printf("pid: %i\n", pid); + + while (!v); +} diff --git a/code/test/gack/module.mk.in b/code/test/gack/module.mk.in new file mode 100644 index 0000000..61ab7bb --- /dev/null +++ b/code/test/gack/module.mk.in @@ -0,0 +1,24 @@ + +DIR := test/gack + +TEST_GACK_GSSRC += $(shell cd @SRC_ABSOLUTE_TOP@; find $(DIR) -name "*.gs" ) +TEST_GACK_SRC += $(shell cd @SRC_ABSOLUTE_TOP@; find $(DIR) -name "*.c" ) +TEST_GSSRC += $(TEST_GACK_GSSRC) + +TEST_GACK_OBJS := $(patsubst %.gs, %.o, $(TEST_GACK_GSSRC)) +TEST_GACK_PROGS := $(patsubst %.gs, %.x, $(TEST_GACK_GSSRC)) + +TEST_OBJS += $(TEST_GACK_OBJS) +TEST_PROGS += $(TEST_GACK_PROGS) + +# GACK tests + +# Separate rule for local function tests: +# test/gack/test01.x: test/gack/test01.o $(GACK) +# $(Q) " MPICC $(@)" +# $(E)$(MPICC) -rdynamic -L src/gsl/lib $(<) $(GACK) -l gs -l gstest $(LIBS) -o $(@) + +test/gack/test%.x: test/gack/test%.o $(GACK) src/gobs/launch.o + $(Q) " MPICC $(@)" + $(E)$(MPICC) -rdynamic -L src/gsl/lib $(<) src/gobs/launch.o src/gobs/client.o $(GACK) -l gs -l gstest -l crypto -l m $(LIBS) -o $(@) + diff --git a/code/test/skullfs/test02.gs b/code/test/gack/test01.gs similarity index 57% copy from code/test/skullfs/test02.gs copy to code/test/gack/test01.gs index 31037d8..d77ae70 100644 --- a/code/test/skullfs/test02.gs +++ b/code/test/gack/test01.gs @@ -1,6 +1,6 @@ /** - TEST02: Simple lookup. + TEST01: Simple local allocation. */ #include <stdbool.h> @@ -17,18 +17,12 @@ __blocking int gobs_client_code() { - gobs_id id; + gack_sack sack; + + gack_allocate(&sack); - gum_node target; - - target.rank = 0; - target.comm = MPI_COMM_WORLD; - - id = skullfs_mkfs(target); - assert(id == 0); + gack_printf_sack(&sack); - printf("id: %i\n", id); - return 1; } diff --git a/code/test/gobs/About.txt b/code/test/gobs/About.txt new file mode 100644 index 0000000..9ff651d --- /dev/null +++ b/code/test/gobs/About.txt @@ -0,0 +1,4 @@ + +test01: Simple lookup and store. +test02: Simple lookup and store and retrieve. +test03: AIT tests diff --git a/code/test/gobs/test03.gs b/code/test/gobs/test03.gs index 5629ffa..481eff2 100644 --- a/code/test/gobs/test03.gs +++ b/code/test/gobs/test03.gs @@ -1,6 +1,6 @@ /** - TEST03: NOT USED + TEST03: AIT Tests. */ #include <stdbool.h> @@ -11,114 +11,21 @@ #include <include/gs.h> #include <resources/mpi/gs-mpi.gsh> -#include <gobs.h> +#include <gobs.gsh> -char buffer[100]; +#include <test/common/gdb_wait_loop.c> -int done = 0; - -static void -done_callback(void *user_ptr, int ret) -{ - done = 1; -} - -__blocking int -bootstrap(void) -{ - MPI_Status status; - gum_node target; - gum_node recipient; - gum_msg* msg; - gum_msg* result; - - gobs_id key = 3; - char data[128]; - int length; - - if (mpi_rank == 0) - { - gobs_init(GOBS_DENSE, MPI_COMM_WORLD); - while (gobs_running) - { - gobs_response(MPI_COMM_WORLD); - } - } - else - { - gobs_init(GOBS_DENSE, MPI_COMM_WORLD); - target.rank = 0; - target.comm = MPI_COMM_WORLD; - - pwait - { - pbranch - { - recipient = gobs_query(target, key); - length = gobs_retrieve(recipient, key, data); - printf("recvd: %i chars\n", length); - printf("data: %s\n", data); - gobs_quit(target); - target.rank = 1; - gobs_quit(target); - } - pbranch - { - while (gobs_running) - { - gobs_response(MPI_COMM_WORLD); - } - } - } - } - - return 0; -} - -void -gdb_startup(void) +__blocking int +gobs_client_code() { - int gdb_wait = 0; + gum_node target; - pid_t pid = getpid(); - printf("pid: %i\n", pid); - fflush(stdout); - -// if (mpi_rank == 1) - while (!gdb_wait); -} - -int -main(int argc, char *argv[]) -{ - gs_op_id_t op_id; - gs_context_t ctx; - - MPI_Init(&argc, &argv); - - MPI_Comm_size(MPI_COMM_WORLD, &mpi_size); - MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank); + // gdb_wait_loop(); - // gdb_startup(); + target.rank = 0; + target.comm = MPI_COMM_WORLD; - gs_mpi_init(); + gobs_ait_pull(target); - memset(buffer, '\0', 100); - - gs_context_create(&ctx, 1, "mpi"); - gum_init(); - - bootstrap_post(done_callback, NULL, NULL, ctx, &op_id); - - while (done == 0) - { - gs_poll(ctx, 10); - } - - printf("finalize\n"); - MPI_Finalize(); - - gs_mpi_finalize(); - gs_context_destroy(ctx); - return 0; + return 1; } diff --git a/code/test/skullfs/About.txt b/code/test/skullfs/About.txt index 083c648..ef44f7c 100644 --- a/code/test/skullfs/About.txt +++ b/code/test/skullfs/About.txt @@ -3,5 +3,6 @@ test01: Test local functions. test02: Just setup FS. test03: Make some directories. test04: Make a file. -test05: Make a file and write into it. -test06: Make a file, write to it, read it back. +test05: Make a file and open it. +test06: Make a file and write into it. +test07: Make a file, write to it, read it back. diff --git a/code/test/skullfs/test02.gs b/code/test/skullfs/test02.gs index 31037d8..8b4eb40 100644 --- a/code/test/skullfs/test02.gs +++ b/code/test/skullfs/test02.gs @@ -1,6 +1,6 @@ /** - TEST02: Simple lookup. + TEST02: Simple startup. */ #include <stdbool.h> @@ -24,7 +24,7 @@ gobs_client_code() target.rank = 0; target.comm = MPI_COMM_WORLD; - id = skullfs_mkfs(target); + skullfs_mkfs(target, &id); assert(id == 0); printf("id: %i\n", id); diff --git a/code/test/skullfs/test05.gs b/code/test/skullfs/test05.gs index 32334f1..24d1b62 100644 --- a/code/test/skullfs/test05.gs +++ b/code/test/skullfs/test05.gs @@ -7,7 +7,7 @@ #include <skullfs_client.gsh> void -gdb_wait() +gdb_wait_loop() { int v = 0; @@ -25,6 +25,8 @@ gobs_client_code() gum_node target; + skullfs_fd fd; + int count; char** names; int* ids; @@ -32,7 +34,7 @@ gobs_client_code() char data[32]; - // gdb_wait(); + // gdb_wait_loop(); strcpy(data, "hello!"); @@ -49,11 +51,20 @@ gobs_client_code() skullfs_ls(target, root_id, &count, &names, &ids); for (i = 0; i < count; i++) { - printf("entry: %i %s %i\n", i, names[i], ids[i]); + printf(" entry: %i %s %i\n", i, names[i], ids[i]); } - printf("test05: write\n"); - skullfs_pwrite(target, file_id, data, strlen(data), 0); + printf("test05: open\n"); + + skullfs_open(target, file_id, &fd); + + printf("sack->size: %i\n", fd.sack.size); + for (i = 0; i < fd.sack.size; i++) + { + printf(" id: %i\n", fd.sack.id[i]); + } + + // skullfs_pwrite(target, file_id, data, strlen(data), 0); return 1; } diff --git a/code/test/skullfs/test05.gs b/code/test/skullfs/test06.gs similarity index 57% copy from code/test/skullfs/test05.gs copy to code/test/skullfs/test06.gs index 32334f1..59d9eab 100644 --- a/code/test/skullfs/test05.gs +++ b/code/test/skullfs/test06.gs @@ -5,9 +5,8 @@ #include <gobs.gsh> #include <skullfs_client.gsh> - void -gdb_wait() +gdb_wait_loop() { int v = 0; @@ -25,14 +24,11 @@ gobs_client_code() gum_node target; - int count; - char** names; - int* ids; - int i; - + skullfs_fd fd; + char data[32]; - // gdb_wait(); + // gdb_wait_loop(); strcpy(data, "hello!"); @@ -42,18 +38,14 @@ gobs_client_code() skullfs_mkfs(target, &root_id); assert(root_id == 0); - printf("test05: create:\n"); + printf("test06: create:\n"); skullfs_create(target, root_id, "file", &file_id); - printf("test05: list after create:\n"); - skullfs_ls(target, root_id, &count, &names, &ids); - for (i = 0; i < count; i++) - { - printf("entry: %i %s %i\n", i, names[i], ids[i]); - } + printf("test06: open\n"); + + skullfs_open(target, file_id, &fd); - printf("test05: write\n"); - skullfs_pwrite(target, file_id, data, strlen(data), 0); + skullfs_pwrite(target, &fd, data, strlen(data), 0); return 1; } diff --git a/code/test/skullfs/test05.gs b/code/test/skullfs/test07.gs similarity index 57% copy from code/test/skullfs/test05.gs copy to code/test/skullfs/test07.gs index 32334f1..35225fb 100644 --- a/code/test/skullfs/test05.gs +++ b/code/test/skullfs/test07.gs @@ -5,9 +5,8 @@ #include <gobs.gsh> #include <skullfs_client.gsh> - void -gdb_wait() +gdb_wait_loop() { int v = 0; @@ -25,14 +24,12 @@ gobs_client_code() gum_node target; - int count; - char** names; - int* ids; - int i; - + skullfs_fd fd; + char data[32]; - - // gdb_wait(); + char copy[32]; + + // gdb_wait_loop(); strcpy(data, "hello!"); @@ -42,18 +39,18 @@ gobs_client_code() skullfs_mkfs(target, &root_id); assert(root_id == 0); - printf("test05: create:\n"); + printf("test06: create:\n"); skullfs_create(target, root_id, "file", &file_id); - printf("test05: list after create:\n"); - skullfs_ls(target, root_id, &count, &names, &ids); - for (i = 0; i < count; i++) - { - printf("entry: %i %s %i\n", i, names[i], ids[i]); - } + printf("test06: open\n"); + + skullfs_open(target, file_id, &fd); + + skullfs_pwrite(target, &fd, data, strlen(data), 0); + + skullfs_pread(target, &fd, copy, strlen(data), 0); - printf("test05: write\n"); - skullfs_pwrite(target, file_id, data, strlen(data), 0); + printf("read copy: %s\n", copy); return 1; } diff --git a/sim/gobs/About.txt b/sim/gobs/About.txt index b29c065..0ca351f 100644 --- a/sim/gobs/About.txt +++ b/sim/gobs/About.txt @@ -1,18 +1,27 @@ GOBS: Simulator -Compile with: +Compile and run with: + javac GOBS.java +java GOBS + +or + +ant +java -jar GOBS.jar -Run with: +Run with arguments: -java GOBS <B> <nodes> <objects> + <B> <nodes> <files> <file size> <object size> where: B is the bit length of the addresses nodes is the number of object stores -objects is the number of objects +files is the number of files +file size is the size of each file +objects size is the chunk size within a file The simulator simply assigns the objects to the nodes in accordance with the (Kademlia) XOR metric. diff --git a/sim/gobs/Addressable.java b/sim/gobs/Addressable.java index 0f03854..e96ffa6 100644 --- a/sim/gobs/Addressable.java +++ b/sim/gobs/Addressable.java @@ -1,6 +1,10 @@ import java.math.BigInteger; +/** + * Superclass for things with an address: objects and nodes. + * */ + class Addressable { int B; @@ -14,7 +18,10 @@ class Addressable this.B = B; this.id = id; } - + + /** + Does this Addressable start with the given bit prefix? + */ boolean prefix(int[] p) { int[] A = bitArray(); @@ -25,7 +32,10 @@ class Addressable } return true; } - + + /** + Obtain an array of bits for this Addressable. + */ int[] bitArray() { if (array != null) @@ -36,6 +46,9 @@ class Addressable return result; } + /** + Obtain the array of bits for the given address. + */ static int[] bitArray(int B, BigInteger i) { int[] result = new int[B]; @@ -52,20 +65,26 @@ class Addressable return result; } - + + /** + Convert the Addressable to a String of 0s and 1s. + */ String bitString() { return bitString(B, id); } /** - Bits in integer < 2^B. + Convert the given address to a String of 0s and 1s. */ static String bitString(int B, BigInteger i) { return arrayString(bitArray(B, i)); } + /** + Convert the given bits to a String. + */ static String arrayString(int[] bits) { StringBuilder buffer = new StringBuilder(); @@ -79,11 +98,12 @@ class Addressable return buffer.toString(); } - /** - Debugging only. - */ + /* + Debugging only. + public static void main(String[] args) { // System.out.println(bitString(10, )); } + */ } diff --git a/sim/gobs/Bits.java b/sim/gobs/Bits.java index 1062790..d6dd4db 100644 --- a/sim/gobs/Bits.java +++ b/sim/gobs/Bits.java @@ -4,7 +4,8 @@ import java.util.*; /** * Provides random bits, statically. * Kills VM exit code 2 on misuse. - */ + * */ + public class Bits { public static Random rng = null; diff --git a/sim/gobs/GOBS.java b/sim/gobs/GOBS.java index 315a225..1dd7124 100644 --- a/sim/gobs/GOBS.java +++ b/sim/gobs/GOBS.java @@ -1,17 +1,17 @@ -/** - GOBS placement simulator - - Usage: GOBS <B> <nodes> <objects> - - B: Bit length of addresses - nodes: Number of nodes - objects: Number of objects -*/ - - import java.util.*; +/** + * <h3> GOBS placement simulator. </h3> + * + * Command-line arguments: <br> + * B: Bit length of addresses <br> + * nodes: Number of nodes <br> + * fileCount: Number of files <br> + * fileSize: Size of each file <br> + * objSize: Size of each object + * */ + class GOBS { static int B; @@ -92,9 +92,7 @@ class GOBS } // Place objects and add up load... - System.out.println("placing..."); placer.place(objects, nodes); - System.out.println("done"); Map<Node,Integer> origCount = countObjects(nodes); // printNodes(nodes); @@ -102,7 +100,6 @@ class GOBS // Cause a fault and reallocate objects... int index = Bits.nextInt(nodes.size()); - System.out.println("index: " + index); Node failed = nodes.remove(index); System.out.println("failed: " + failed.bitString() + " (" + failed.objects.size() + ")"); @@ -112,19 +109,19 @@ class GOBS Map<Node,Integer> faultCount = countObjects(nodes); // Find the load difference from before the fault... - List<Integer> adds = new ArrayList<Integer>(); + List<Integer> diffs = new ArrayList<Integer>(); for (Node node : faultCount.keySet()) { int before = origCount.get(node); int after = faultCount.get(node); - adds.add(after-before); + diffs.add(after-before); } // Display load differences... System.out.println(""); System.out.println("LOAD INCREASES:"); - Collections.sort(adds); - for (Integer i : adds) + Collections.sort(diffs); + for (Integer i : diffs) System.out.println(i); } } diff --git a/sim/gobs/Kademlia.java b/sim/gobs/Kademlia.java index 2cbc434..886da8d 100644 --- a/sim/gobs/Kademlia.java +++ b/sim/gobs/Kademlia.java @@ -2,6 +2,10 @@ import java.math.BigInteger; import java.util.List; +/** + * Places objects on the nearest node using the XOR distance metric. + * */ + class Kademlia implements PlacementScheme { diff --git a/sim/gobs/LayoutScheme.java b/sim/gobs/LayoutScheme.java index 3fe2c1a..1222f50 100644 --- a/sim/gobs/LayoutScheme.java +++ b/sim/gobs/LayoutScheme.java @@ -2,6 +2,10 @@ import java.math.BigInteger; import java.util.List; +/** + * LayoutSchemes generate object ids within a file. + * */ + abstract class LayoutScheme { int B; diff --git a/sim/gobs/Node.java b/sim/gobs/Node.java index 696152c..71d1859 100644 --- a/sim/gobs/Node.java +++ b/sim/gobs/Node.java @@ -2,6 +2,10 @@ import java.math.BigInteger; import java.util.*; +/** + * Simulates an object store. + * */ + class Node extends Addressable { diff --git a/sim/gobs/NodeScheme.java b/sim/gobs/NodeScheme.java index e44063f..09b3d1a 100644 --- a/sim/gobs/NodeScheme.java +++ b/sim/gobs/NodeScheme.java @@ -1,6 +1,10 @@ import java.util.*; +/** + * Generates node addresses. + * */ + abstract class NodeScheme { int B; @@ -11,6 +15,10 @@ abstract class NodeScheme this.B = B; M = Math.round(Math.pow(2,B)); } - + + /** + Generate <tt>count</tt> new nodes and place them in + <tt>nodes</tt>. + */ abstract void generate(int count, List<Node> nodes); } diff --git a/sim/gobs/Obj.java b/sim/gobs/Obj.java index 263147f..c3ce9a2 100644 --- a/sim/gobs/Obj.java +++ b/sim/gobs/Obj.java @@ -2,8 +2,9 @@ import java.math.BigInteger; /** - Identifier "Object" is used by Java. -*/ + * Simulates a single object. + * Identifier "Object" is used by Java. + * */ class Obj extends Addressable diff --git a/sim/gobs/PlacementScheme.java b/sim/gobs/PlacementScheme.java index ffdf195..2b58b60 100644 --- a/sim/gobs/PlacementScheme.java +++ b/sim/gobs/PlacementScheme.java @@ -1,6 +1,10 @@ import java.util.List; +/** + * Interface to place a list of objects on a set of nodes. + * */ + interface PlacementScheme { void place(List<Obj> objects, List<Node> nodes); diff --git a/sim/gobs/RandomLayout.java b/sim/gobs/RandomLayout.java index afc9e55..675325e 100644 --- a/sim/gobs/RandomLayout.java +++ b/sim/gobs/RandomLayout.java @@ -2,6 +2,10 @@ import java.math.BigInteger; import java.util.*; +/** + * Generates random object ids. + * */ + class RandomLayout extends LayoutScheme { diff --git a/sim/gobs/RandomNodes.java b/sim/gobs/RandomNodes.java index 9866eea..c625831 100644 --- a/sim/gobs/RandomNodes.java +++ b/sim/gobs/RandomNodes.java @@ -2,6 +2,10 @@ import java.math.BigInteger; import java.util.*; +/** + * Places new nodes randomly without looking at existing nodes. + * */ + class RandomNodes extends NodeScheme { @@ -9,7 +13,7 @@ class RandomNodes { super(B); } - + public void generate(int count, List<Node> nodes) { for (int i = 0; i < count; i++) diff --git a/sim/gobs/UniformNodes.java b/sim/gobs/UniformNodes.java index 7d2d8a1..9f2988c 100644 --- a/sim/gobs/UniformNodes.java +++ b/sim/gobs/UniformNodes.java @@ -3,7 +3,7 @@ import java.math.BigInteger; import java.util.*; /** - * UNIFORMNODES: New nodes insert themselves in the middle of + * New nodes insert themselves in the middle of * the largest gap in the node address space. * */ @@ -74,6 +74,9 @@ class UniformNodes return children(A, 0); } + /** + Helper for allPossible(). + */ Set<int[]> children(int[] A, int b) { Set<int[]> result = new HashSet<int[]>(); @@ -111,12 +114,6 @@ class UniformNodes return result; } - - /** - @param count The number of new nodes to generate. - @param nodes The existing nodes. - New nodes are added to this List. - */ public void generate(int count, List<Node> nodes) { for (int i = 0; i < count; i++) @@ -126,9 +123,9 @@ class UniformNodes } } - /** + /* Debugging only. - */ + public static void main(String[] args) { int B = 6; @@ -146,4 +143,5 @@ class UniformNodes // System.out.println(allPossible(3)); } + */ } hooks/post-receive -- Grayskull Repository