| _of_int_page [Pkv_xdr_aux] | |
| _of_key [Pkv_xdr_aux] | |
| _of_key_p [Pkv_xdr_aux] | |
| _of_leaf_page [Pkv_xdr_aux] | |
| _of_page [Pkv_xdr_aux] | |
| _of_page_type [Pkv_xdr_aux] | |
| _of_root_page [Pkv_xdr_aux] | |
| _to_int_page [Pkv_xdr_aux] | |
| _to_key [Pkv_xdr_aux] | |
| _to_key_p [Pkv_xdr_aux] | |
| _to_leaf_page [Pkv_xdr_aux] | |
| _to_page [Pkv_xdr_aux] | |
| _to_page_type [Pkv_xdr_aux] | |
| _to_root_page [Pkv_xdr_aux] | |
A | |
| abort [Pkv_api] |
Throws changes away, and closes the db.
|
| abort [Plasma_client] |
Aborts a transaction, and abandons the changes of the transaction
|
| abort_cluster [Plasma_client] |
Closes the descriptors to remote services so far possible, but
does not permanently shut down the client functionality.
|
| abort_e [Pkv_api] |
Same as async function
|
| abort_e [Plasma_client] | |
| activate_timers [Nn_coord] |
Called when we can run transactions to enable the housekeeping
timers.
|
| add [Mapred_toolkit.Seq] | let s2 = add x s1: Adds the element to the underlying store,
and returns a new sequence where the new element is visible at
the end.
|
| add [Mapred_stats] | |
| add [Nn_monitor] |
Add the datastore record as-is (for initializing this module from db).
|
| add_inputs [Mapred_sched] |
Add the input files, and create map tasks.
|
| add_map_output [Mapred_sched] |
Add these files as output of this map/emap task identified by this ID
|
| add_service [Dn_io] |
Adds the
Dn_io service directly to the controller.
|
| addl [Mapred_toolkit.Seq] |
adds several elements
|
| addl [Mapred_stats] | |
| admin_table_exists_e [Nn_db] |
Just return whether the key exists
|
| admin_table_exists_ro_e [Nn_db] |
same, using an ro transaction
|
| admin_table_get_e [Nn_db] |
Gets the contents of the admin table
key
|
| admin_table_get_ro_e [Nn_db] |
same, using an ro transaction
|
| admin_table_put_e [Nn_db] |
Overwrite this admin table
|
| alloc_wait_entry [Pfs_condition] |
Allocates a
wait_entry
|
| allocate_balanced_strategy [Nn_alloc_balanced] | allocate_balanced_strategy inode bmaps td owner repl index number bs pref:
Allocates blocks for the index range index to index+number-1.
|
| allocate_trivial_strategy [Nn_alloc_trivial] | allocate_trivial_strategy bmaps td owner repl index number:
Allocates blocks for the index range index to index+number-1.
|
| allocinfo_get_e [Nn_db] |
Retrieves the complete allocinfo for this inode
|
| allocinfo_get_ro_e [Nn_db] |
same, using an ro transaction
|
| append [Mapred_toolkit.Seq] | let s3 = append s1 s2: Adds all elements visible via s2 to the
end of the store of s1, and returns a new seq s3 where the
new elements are visible.
|
| apply_partially [Mapred_rfun] |
Create a new rfun by applying the first argument only.
|
| auto_input_format [Mapred_io] |
This "format" recognizes the format for input files by the
file suffix (".var", "fixed<n>", or nothing).
|
| avg_runnable [Mapred_sched] |
Average number of runnable tasks (excl.
|
| avg_running [Mapred_sched] |
Average number of running tasks
|
| avg_runqueue [Mapred_sched] |
Average number of running or runnable tasks
|
B | |
| ba_merge_sort [Mapred_sort] | |
| begin_transaction_e [Nn_push] |
Starts the transaction:
begin_transaction_e c clustername exp_rev.
|
| bigblock_size [Mapred_sched] |
The effective size of bigblocks.
|
| bigblock_size [Mapred_io] | bigblock_size fs path suggested: Returns the real bigblock size for
the suggested value.
|
| blit_from_buffer [Plasma_filebuf] | |
| blit_memory [Plasma_platform] | blit_memory src srcoff dst dstoff len copies len characters
from buffer src, starting at character number srcoff, to
string dst, starting at character number dstoff
|
| blit_to_buffer [Plasma_filebuf] | |
| blockalloc_list_e [Nn_db] |
Reads the blockalloc table for this
datastore ID.
|
| blockalloc_list_ro_e [Nn_db] |
same, using an ro transaction
|
| blockalloc_upd_e [Nn_db] |
Updates the
blockalloc table
|
| blockmap_from_db_e [Nn_blockmap] |
Create a blockmap object, and initialize it from the
blockalloc
db table
|
| blocksize [Dn_shm] |
Returns
dn_blocksize
|
| blocksize [Plasma_client] |
Returns the blocksize
|
| blocksize_e [Plasma_client] | |
| bmaprowsize [Nn_config] |
block map row size - how many bits are in one row of the block map.
|
| bottom_user [Pfs_auth] |
The name of the user with minimum rights: "pnobody" (Plasma nobody)
|
| broadcast [Pfs_condition] | broadcast c restarts all processes waiting on the
condition variable c.
|
| bset_of_blocklist [Plasma_blocks] |
Converts a normal blocklist into a set of block ranges
|
| buffer [Mapred_io_bgreader] |
Returns the buffer.
|
| buffer_block [Mapred_io_bgreader] |
Returns the block position of
buffer
|
| buffer_len [Mapred_io_bgreader] |
Returns the length of
buffer in blocks
|
C | |
| cardinal [Nn_blocklist] |
The number of covered blocks (incl.
|
| check_up_to_date_e [Plasma_inodecache] | check_up_to_date_e icm mc lt inode seqno: Checks whether seqno is
the most recent committed sequence number of inode.
|
| clean_access [Plasma_filebuf] |
a clean buffer is continued to be used as clean buffer
after a read access
|
| cleanup [Mapred_job_exec] |
Deletes all temp files (sync)
|
| clear [Mapred_toolkit.Place] |
Deletes all files at this place the
files function returns.
|
| client [Nn_blockmap_box] |
Create a client
|
| close [Mapred_toolkit.Store] |
Flushes unwritten data to disk (when writing to a store), and
closes all OS resources
|
| close [Mapred_io_bgreader] |
Closes the reader
|
| close_cluster [Plasma_client] |
Closes all file descriptors permanently
|
| close_store [Dn_store] |
Closes the store
|
| cluster [Plasma_client] |
the cluster to which a transaction belongs
|
| cluster_name [Plasma_client] |
Returns the cluster name
|
| cluster_namenodes [Plasma_client] |
Returns the namenodes passed to
open_cluster
|
| cmp [Mapred_sorters.Float_xdr_desc] | |
| cmp [Mapred_sorters.Float_xdr_asc] | |
| cmp [Mapred_sorters.Int64_xdr_desc] | |
| cmp [Mapred_sorters.Int64_xdr_asc] | |
| cmp [Mapred_sorters.Float_desc] | |
| cmp [Mapred_sorters.Float_asc] | |
| cmp [Mapred_sorters.Hex_desc] | |
| cmp [Mapred_sorters.Hex_asc] | |
| cmp [Mapred_sorters.Integer_desc] | |
| cmp [Mapred_sorters.Integer_asc] | |
| cmp [Mapred_sorters.String_desc] | |
| cmp [Mapred_sorters.String_asc] | |
| cmp [Mapred_sorters.Grouped] | |
| commit [Pkv_api] |
Commits changes, and closes the db.
|
| commit [Plasma_client] |
Commits a transaction, and makes the changes of the transaction
permanent.
|
| commit_all_prepared_transactions [Nn_db] |
Commits all prepared transactions at system startup
|
| commit_e [Nn_commit] | commit_e get_journal get_journal_mon post_commit shared_state debug_name:
|
| commit_e [Nn_push] |
Commits the transaction
|
| commit_e [Plasma_client] | |
| compare [Mapred_tasks.Ord] |
Compare here the tasks in an execution-friendly order, i.e.
|
| complete_inputs [Mapred_sched] |
Declare that no more inputs will be added.
|
| configure_auth [Plasma_client] | configure_auth c nn_user dn_user get_password: Configures that accesses
to the namenode are authenticated on the RPC level as nn_user and
accesses to datanodes
are authenticated as dn_user.
|
| configure_auth_daemon [Plasma_client] |
Configures that the authentication daemon is contacted to get
evidence about the current user.
|
| configure_auth_ticket [Plasma_client] |
Configures that this ticket proves the identity of the user.
|
| configure_buffer [Plasma_client] | configure_buffer c n: configures to use n buffers.
|
| configure_default_user_group [Plasma_client] | configure_default_user_group c user group: Normally, new files are
created as the user and group corresponding to the current
impersonation.
|
| configure_plan [Mapred_sched] | configure_plan jc conf
|
| configure_pref_nodes [Plasma_client] |
Configures that the data nodes with the given identities are
preferred for the allocation of new blocks.
|
| configure_pref_nodes_of_inode [Plasma_client] |
Similar to
configure_pref_nodes, but this list overrides the
global setting for this inode.
|
| configure_rpc_server [Mapred_auth] |
Configures the RPC server so the passed level of access protection
is required.
|
| configure_rpc_server [Pfs_auth] |
Configures the RPC server so the passed level of access protection
is required.
|
| configure_shm_manager [Plasma_client] |
Configures a shared memory manager.
|
| consistency_check_e [Nn_db] |
Performs a quite costly consistency check.
|
| copy_in [Plasma_client] | copy_in_e c inode pos fd len: Copies the data from the file descriptor
fd to the file given by inode.
|
| copy_in_e [Plasma_client] | |
| copy_in_from_buf [Plasma_client] | copy_in_from_buf c inode pos buf len: Copies the data from
buf to the file denoted by inode.
|
| copy_in_from_buf_e [Plasma_client] | |
| copy_out [Plasma_client] | copy_out_e c inode pos fd len Copies the data from the file referenced
by inode to file descriptor fd.
|
| copy_out_e [Plasma_client] | |
| copy_out_to_buf [Plasma_client] | copy_out_to_buf_e c inode pos buf len Copies the data from the
file denoted by inode to the buffer buf.
|
| copy_out_to_buf_e [Plasma_client] | |
| counters [Nn_state] | |
| create [Platform.Line_splitter] |
Creates the line splitter thread
|
| create [Mapred_toolkit.Place] |
Creates a new empty place.
|
| create [Mapred_io_bgreader] | create fs name startblock endblock bufnum
|
| create [Nn_authticket] |
Create a new authentication ticket (verifier) for this user ID.
|
| create [Dn_shm] |
Creates the shm object and returns its name
|
| create_bl_cache [Plasma_inodecache] | create_bl_cache mc lt inode:
Create a cache for this transaction.
|
| create_buffer_system [Plasma_filebuf] | create_buffer_system n_bufs blocksize esys
|
| create_client [Nn_push] |
Creates a new client.
|
| create_commit_monitor [Nn_commit_monitor] | |
| create_commit_monitor_heap [Nn_commit_monitor] | |
| create_condition [Pfs_condition] | create m: Creates a condition variable, and
pushes it to the heap, using the mutator m.
|
| create_config [Mapred_toolkit.DSeq] |
The default values for the configurations are taken from
mapred_env,
and are effectively taken from the .conf files.
|
| create_dir [Mapred_io] | create_dir fs name: Creates a directory exclusively
|
| create_file [Mapred_toolkit.Place] | create_file pl:
|
| create_file [Mapred_io] | create_file fs name: Creates this file exclusively.
|
| create_file [Plasma_client] |
Creates a regular file (inode plus name) or a symlink.
|
| create_file_e [Plasma_client] | |
| create_inode [Plasma_client] |
Create a new inode.
|
| create_inode_e [Plasma_client] | |
| create_manager [Plasma_inodecache] | create_manager esys: Creates a new manager.
|
| create_owner [Nn_state] | |
| create_owner [Nn_blockmap] |
The owner is an opaque ID which is guaranteed to be unique in the
whole Netplex system
|
| create_plan [Mapred_sched] |
Creates a plan.
|
| create_reserve_info [Nn_blockmap] |
Creates a
reserve_info record
|
| create_runtime_job_config [Mapred_job_exec] |
Especially how many tasks are started per task server.
|
| create_runtime_job_config_from_mapred_config [Mapred_job_exec] |
Like the above function, but gets many values from a
mapred_config
object
|
| create_wait_set [Pfs_condition] |
Creates a
wait_set in the heap designated by the mutator.
|
| current_user [Plasma_client] | let (user,group,supp_groups) = current_user c: Get the identity
of the current client principal on the filesystem level.
|
| current_user_e [Plasma_client] | |
D | |
| datastore_del_e [Nn_db] |
Deletes the datastore with this ID and all rows referencing it
|
| datastore_find_e [Nn_db] |
Find a datastore by identity
|
| datastore_find_ro_e [Nn_db] |
same, using an ro transaction
|
| datastore_list_e [Nn_db] |
Gets a list of all datastores
|
| datastore_list_ro_e [Nn_db] |
same, using an ro transaction
|
| datastore_upd_e [Nn_db] |
Updates the datastore table.
|
| decode_alt64 [Mapred_fields] |
Encode/decode a binary string using the "ALT-64" method.
|
| decode_task [Mapred_tasks] | |
| decode_task_result [Mapred_tasks] | |
| delete [Pkv_api] | delete db key: Deletes this key, if it exists
|
| delete [Nn_monitor] | delete identity: Remove this store
|
| delete [Nn_dentrycache] |
Deletes this entry from the cache
|
| delete [Nn_inodecache] |
Deletes this inode from the cache
|
| delete [Nn_authticket] | |
| delete_file [Mapred_io] |
Delete this file or empty dir
|
| delete_inode [Plasma_client] |
Delete the inode
|
| delete_inode_e [Plasma_client] | |
| delete_rec [Mapred_io] |
Deletes this file or directory recursively
|
| delete_registered_objects [Pfs_pmanage] |
Delete all the objects on disk, and clear the registry
|
| destroy_condition [Pfs_condition] | |
| destroy_wait_set [Pfs_condition] |
Destroys these objects
|
| dir_ii [Plasma_client] | regular_ii c mode: Creates an inodeinfo record for a new
directory, where the mode field is set to mode modulo
the current mask
|
| dir_lookup [Plasma_client] |
Looks the filename up relative to a directory (given as inode)
and returns the inode number.
|
| dir_lookup_e [Plasma_client] | |
| dirty_access [Plasma_filebuf] |
A clean or invalid buffer is set to dirty.
|
| disable [Nn_monitor] | disable identity: Sets enabled to false
|
| disable [Plasma_inodecache] |
Disables the cache.
|
| disable_ticket_verifier [Nn_datanode_ctrl] | disable_ticket_verifier tv f_post: Schedules that tv will be
disabled soon.
|
| disconnect [Nn_datanode_ctrl] |
Disconnects from this datanode
|
| dispatch [Mapred_main] |
Alternative main program for dispatching between several types
of jobs.
|
| divide [Mapred_io] |
Divides
buffer_size and buffer_size_tight by this number
|
| domain [Nn_blocklist] |
Returns the list of ranges covered by the blocklist (i.e.
|
| drop_inode [Plasma_client] |
Drops all buffers of this inode, including dirty ones.
|
| ds_cache_contents [Nn_db] |
Gets the contents of the cache
|
| ds_cache_init [Nn_db] |
This module provides an internal cache of the datastore ID to
datastore identity mapping.
|
| dummy_condition [Pfs_condition] |
A dummy condition is non-functional, but can be used to put something
into
condition-typed variables
|
| dummy_db_config [Pfs_db] | |
| dummy_wait_set [Pfs_condition] |
A dummy
wait_set is non-functional, but can be used to put something
into wait_set-typed variables
|
| dump_buffers [Plasma_client] |
debug report
|
| dump_buffers [Plasma_filebuf] |
Writes the buffer table to log (debug level)
|
E | |
| elect_e [Nn_elect] |
Do the election.
|
| empty [Mapred_stats] | |
| empty [Nn_blocklist] |
an empty blocklist
|
| empty_ticket [Nn_blocklist] |
A dummy ticket (used during blocklist construction)
|
| enable [Nn_monitor] | enable identity: Sets enabled to true
|
| enable [Plasma_inodecache] |
Enables the cache.
|
| enable_ticket_verifier_e [Nn_datanode_ctrl] |
Pushes a safetrans secret to all enabled datanodes.
|
| encap_time [Nn_state] |
Turn the time (as seconds since epoch) into the RPC version
|
| encode_alt64 [Mapred_fields] | |
| encode_task [Mapred_tasks] | |
| encode_task_result [Mapred_tasks] | |
| escape [Mapred_fields] | |
| event_system [Mapred_job_exec] | |
| event_system [Plasma_client] |
Returns the event system
|
| exec_e [Nn_db] |
Performs the passed modification
|
| exec_job [Mapred_main] |
Command-line interface for running this job.
|
| executable_tasks [Mapred_sched] |
Returns all tasks that are executable.
|
| executable_version [Mapred_config] |
Returns an MD5 sum of the running executable
|
| execute [Mapred_task_exec] |
Executes this task
|
| expand_blocklist [Plasma_inodecache] |
Expands the blockinfo structs, and returns only structs with
length=1
|
| extend [Mapred_toolkit.Seq] |
Returns the sequence view on the end of the store.
|
| extend [Mapred_io_bgreader] | extend bgreader endblock: Sets a new endblock (higher value than the
old endblock)
|
| extract_access_config [Mapred_auth] |
Extracts a config section from a Netplex config file like:
|
| extract_access_config [Pfs_auth] |
Extracts a config section from a Netplex config file like:
|
| extract_client_config [Pfs_auth] |
Extracts a config section from a Netplex config file like:
|
| extract_config [Mapred_config] |
Config section must look like:
|
| extract_db_config [Pfs_db] |
Extracts the
db_config from this Netplex config file:
|
| extract_dn_config [Dn_config] |
Config section must look like (see
Dn_config.dn_config
for explanations):
|
| extract_job_config [Mapred_job_config] | let (jc, mjc) = extract_job_config cf args custom_params:
|
| extract_min_config [Nn_config] |
Config section must look like (see
Nn_config.nn_node_config
for explanations):
|
| extract_node_config [Nn_config] |
Config section must look like (see
Nn_config.nn_node_config
for explanations):
|
F | |
| factory [Mapred_task_server] |
Factory for the processor "mapred_task_server"
|
| factory [Nn_manager] |
Returns this as factory for inclusion into
Netplex_main.startup
|
| factory [Dn_manager] |
Returns this as factory for inclusion into
Netplex_main.startup
|
| factory [Dn_io] |
Returns this as factory for inclusion into
Netplex_main.startup
|
| file_blocks [Mapred_io] |
Get the length of the file in blocks
|
| file_exists [Mapred_io] | file_exists fs name: whether this file, directory or symbolic
link exists
|
| file_name [Mapred_toolkit.Store] |
Returns the absolute file name
|
| files [Mapred_toolkit.Place] |
Returns the files of the place
|
| fill_blockmap [Nn_blockmap] |
Fills the blockmap from db (synchronous)
|
| fill_memory [Plasma_platform] | fill_memory mem pos len x: Fills the buffer mem from
pos to pos+len-1 with character x.
|
| find_lf [Platform] |
Looks for the first LF char from
mem[pos] to mem[endpos-1] and returns
the position.
|
| finish [Mapred_rfun] |
Disables further registrations (at the end of the initialization).
|
| fixed_size_format [Mapred_io] |
A record has exactly n bytes.
|
| flush [Mapred_toolkit.Seq] |
Flushes the underlying store
|
| flush [Mapred_toolkit.Store] |
Flushes the internal buffers (for stores writing to files)
|
| flush [Plasma_client] | flush_e inode pos len: Flushes all buffered data of inode from
pos to pos+len-1, or to the end of the file if len=0.
|
| flush_all [Plasma_client] |
Flushes all buffers.
|
| flush_all_e [Plasma_client] | |
| flush_e [Plasma_client] | |
| fold [Mapred_toolkit.Seq] | fold f a0 s: if the sequence contains the elements
[x0; x1; ...; x(n-1)] this function computes
|
| fold [Nn_blocklist] |
Fold operator
|
| force [Nn_datastore_news] |
Forces that the new version is fetched
|
| forget_blocks [Plasma_inodecache] | forget_blocks blc block n: Forgets these blocks
|
| free_wait_entry [Pfs_condition] |
Frees a
wait_entry
|
| from [Mapred_toolkit.Place] |
Picks up an existing location, and makes the files there accessible
as place
|
| fsstat [Plasma_client] |
Return statistics
|
| fsstat_e [Plasma_client] | |
G | |
| generate_svg [Mapred_sched] |
Return the graph as SVG (once plan complete)
|
| generic_sorter [Mapred_sorters] |
The sorter orders the records first by the hash of the key.
|
| get [Nn_monitor] |
Get the store record by identity string, or raise
Not_found
|
| get [Nn_datastore_news] |
Get the store record by identity string
|
| get_allocsize [Nn_alloc_balanced] |
Get the allocation size for the blocksize.
|
| get_auth_ticket [Plasma_client] | get_auth_ticket user: Get an authentication ticket for this user
|
| get_auth_ticket_e [Plasma_client] | |
| get_blocklist [Plasma_client] | get_blocklist_e t inode block n keep_flag Returns the list of blocks for
blocks block to blocks+n-1.
|
| get_blocklist_e [Plasma_client] | |
| get_blocks_e [Plasma_inodecache] | get_blocks_e blc index number req_seqno: Gets the blocklist
for inode for the index range index to index+number-1.
|
| get_blocks_from_cache_e [Plasma_inodecache] | get_blocks_from_cache_e blc index: Tries to get the
blocks for index from the cache for inode.
|
| get_blocks_via_cache_e [Plasma_inodecache] | get_blocks_via_cache_e blc index: First tries to get the
blocklist for index and inode from the cache
(as in get_blocks_from_cache_e),
and if this fails, requests the blocklist from the server
(as in get_blocks_e).
|
| get_blocksize [Dn_store] |
Returns the block size
|
| get_cached_inodeinfo [Plasma_client] |
Get info about inode.
|
| get_cached_inodeinfo_e [Plasma_client] | |
| get_client_auth [Mapred_auth] |
Requests an authentication ticket
|
| get_codec [Mapred_toolkit.Place] | |
| get_config [Plasma_client_config] | get_config (): This is the standard way for
clients to obtain a config object.
|
| get_coordinator [Nn_elect] |
Return the coordinator in "host:port" syntax.
|
| get_dn_info [Plasma_client] |
Return information about all enabled and live datanodes
(includes identity, size, and host)
|
| get_dn_info_e [Plasma_client] | |
| get_dump_plan_when_complete [Mapred_job_exec] | |
| get_env [Mapred_job_exec] | |
| get_flush_min_eof [Plasma_filebuf] | |
| get_flush_min_mtime [Plasma_filebuf] |
Return the values from the flush record (or
Not_found)
|
| get_format [Mapred_toolkit.Place] | |
| get_fs [Mapred_toolkit.Place] | |
| get_id [Mapred_rfun] |
Returns the ID
|
| get_identity [Dn_store] |
Returns the identity string
|
| get_ii_e [Plasma_inodecache] | get_ii_e icm mc tid inode: Gets the inodeinfo for inode using
transaction tid and the managed client mc.
|
| get_ii_from_cache_e [Plasma_inodecache] | get_ii_from_cache_e icm inode: Looks the inodeinfo up for inode.
|
| get_ii_via_cache_e [Plasma_inodecache] | get_ii_via_cache_e icm mc lt inode: First tries to get the
inodeinfo for inode from the cache (as in get_ii_from_cache_e),
and if this fails, requests the inodeinfo from the server
(as in get_ii_e).
|
| get_inodeinfo [Plasma_client] |
Get info about inode.
|
| get_inodeinfo_e [Plasma_client] | |
| get_job [Mapred_job_exec] | |
| get_job_config [Mapred_job_exec] |
Get the values of these config settings
|
| get_job_local_dir [Mapred_def] |
Returns the directory in the local filesystem where the files
configured in
task_files can be found.
|
| get_job_log_dir [Mapred_def] |
Returns the directory in the local filesystem where
log files can be placed.
|
| get_keep_temp_files [Mapred_job_exec] | |
| get_plan [Mapred_job_exec] | |
| get_rc [Mapred_toolkit.DSeq] |
Returns the record config.
|
| get_rc [Mapred_toolkit.Place] | |
| get_rc [Mapred_def] | get_rc me bigblock_size: Returns a record config for the given
environment and the suggested size of the bigblock
|
| get_report [Mapred_job_exec] | |
| get_report_to [Mapred_job_exec] | |
| get_result [Mapred_toolkit.DSeq] |
Get the computed value (or an exception)
|
| get_rjc [Mapred_job_exec] | |
| get_role [Nn_elect] |
Return the role.
|
| get_simulate [Mapred_job_exec] | |
| get_size [Dn_store] |
Returns the number of blocks
|
| get_tm [Mapred_job_exec] | |
| get_ug_admin [Nn_ug] |
Get the current version of the user/group tables.
|
| get_ug_files [Nn_ug] | |
| get_update_characteristics [Nn_commit_monitor] |
Extract
uc from a queue of DB updates
|
| get_write_eof [Plasma_client] |
Returns the designated new EOF value of pending writes.
|
| get_write_mtime [Plasma_client] |
Returns the designated new mtime value of pending writes.
|
| greediness_points [Mapred_sched] |
Returns points for the task, and the points indicate how valuable
the task is for a "greedy" job execution strategy.
|
H | |
| hash [Mapred_sorters.Float_xdr_desc] | |
| hash [Mapred_sorters.Float_xdr_asc] | |
| hash [Mapred_sorters.Int64_xdr_desc] | |
| hash [Mapred_sorters.Int64_xdr_asc] | |
| hash [Mapred_sorters.Float_desc] | |
| hash [Mapred_sorters.Float_asc] | |
| hash [Mapred_sorters.Hex_desc] | |
| hash [Mapred_sorters.Hex_asc] | |
| hash [Mapred_sorters.Integer_desc] | |
| hash [Mapred_sorters.Integer_asc] | |
| hash [Mapred_sorters.String_desc] | |
| hash [Mapred_sorters.String_asc] | |
| hash [Mapred_sorters.Grouped] | |
| hd [Mapred_toolkit.Seq] |
returns the head element of the sequence
|
| hdl [Mapred_toolkit.Seq] |
returns the first up to n elements as list
|
| hosts [Mapred_sched] |
returns all configured task server hosts
|
I | |
| impersonate [Plasma_client] | impersonate c user group supp_groups ticket:
Become the user on the filesystem level.
|
| impersonate_e [Plasma_client] | |
| init [Nn_blockmap_box] |
Initializations to be run before the server is started.
|
| init [Nn_db] |
The esys is used for ro transactions
|
| init [Plasma_shm.Netplex_shm_manager] |
This can be called from component context to set the low-water
and high-water marks.
|
| init_store [Dn_store] | init_dn_store config identity size:
Initializes the store.
|
| inode_del_e [Nn_db] |
Deletes a row from
inode
|
| inode_error [Plasma_filebuf] |
Whether there is a write error for this inode
|
| inode_get_anonymous_e [Nn_db] |
Returns
n inodes with set anonymous field
|
| inode_get_anonymous_ro_e [Nn_db] | |
| inode_get_e [Nn_db] |
Loads the inode data if existing
|
| inode_get_ro_e [Nn_db] |
same, using an ro transaction
|
| inode_ins_e [Nn_db] |
Inserts a new row into
inode
|
| inode_listall_e [Nn_db] |
list all inode numbers
|
| inode_maxid_e [Nn_db] |
Returns the max ID
|
| inode_maxid_ro_e [Nn_db] |
same, using an ro transaction
|
| inode_set_anonymous_e [Nn_db] |
Sets the
anonymous flag of the inode
|
| inode_upd_e [Nn_db] |
Updates a row in
inode.
|
| inode_upd_time_e [Nn_db] |
Sets the mtime and/or ctime.
|
| inodeblocks_del_e [Nn_db] |
Delete the blocks for
inode in the range from index
blkidx to blkidx+len-1.
|
| inodeblocks_get_e [Nn_db] |
Gets the block information for
inode in the range from index
blkidx to blkidx+len-1.
|
| inodeblocks_get_ro_e [Nn_db] |
same, using an ro transaction
|
| inodeblocks_getall_e [Nn_db] |
Returns list of
(blkidx,block,length) for this inode and this datastore
dsid (for fsck)
|
| inodeblocks_ins_e [Nn_db] |
Insert these blocks.
|
| insert [Pkv_api] | insert db key value: Inserts a new entry, or replaces an
existing entry with the same key.
|
| insert_channel [Pkv_api] | insert_channel db key size: Returns a channel into which the
inserted value must be written.
|
| insert_large [Pkv_api] | insert_large db key size ch: Inserts a new entry, or replaces an
existing entry with the same key.
|
| int64_serializer [Pfs_condition] | int_serializer heap esys:
Creates a serializer that works across processes.
|
| int64_serializer_heap [Pfs_condition] | int_serializer_heap pool n: initializes a shared structure for use with
int_serializer.
|
| int_page [Pkv_xdr_aux] | |
| invalidate_ii [Plasma_inodecache] | invalidate_ii icm inode: Removes information about this inode from
the cache
|
| investigate_machines [Mapred_job_exec] | investigate_machines config auth_ticket job_id:
|
| invoke [Mapred_toolkit] | |
| invoke [Mapred_job] |
Prepare the job, but do not run yet any task.
|
| is_alive [Nn_monitor] | is_alive identity: Returns whether the datanode having this store
is good as seen by the monitor.
|
| is_alive [Nn_datastore_news] | is_alive identity: Returns whether the datanode having this store
is good as seen by the monitor.
|
| is_directory [Mapred_io] | file_exists fs name: whether this directory exists
|
| is_empty [Mapred_toolkit.Seq] |
tests whether the sequence is empty
|
| is_file_place [Mapred_toolkit.Place] |
Whether the place can store files
|
| iter [Mapred_toolkit.Seq] | iter f s: iterates over the elements of s and calls f x for
every element x
|
| iter [Nn_blocklist] | iter f blist: Calls f identity (min,max) bi for all elementary
ranges that can be compressed to one blockinfo bi.
|
| iterate [Pkv_api] | iterate db f: Calls the function f with all keys, in index
order.
|
J | |
| job [Mapred_streaming] |
The streaming job.
|
| job_id [Mapred_toolkit.DSeq] |
Return the job ID
|
K | |
| kill [Mapred_job_exec] |
Kills the job (also async)
|
L | |
| leaf_page [Pkv_xdr_aux] | |
| length [Mapred_toolkit.Seq] | |
| length [Mapred_toolkit.Store] | |
| length [Dn_shm] |
Returns
dn_shm_queue_length
|
| length64 [Mapred_toolkit.Seq] | |
| length64 [Mapred_toolkit.Store] |
These two functions return the number of records.
|
| level_of_string [Pfs_auth] |
Conversions to/from string
|
| line_structured_format [Mapred_io] |
The line structured file format represents every record as a line
in a text file.
|
| link [Plasma_client] |
Links a name with an inode
|
| link_at [Plasma_client] | link_at trans dir_inode name inode: Adds the entry name into
the directory dir_inode and connects the entry with inode.
|
| link_at_e [Plasma_client] | |
| link_count [Plasma_client] |
Returns the number of links (also no locks)
|
| link_count_e [Plasma_client] | |
| link_e [Plasma_client] | |
| list [Nn_monitor] |
Returns the list of all datastores
|
| list [Nn_datastore_news] |
Returns the list of all datastores
|
| list [Plasma_client] |
Lists the contents of the directory, given by filename
|
| list_e [Plasma_client] | |
| list_inode [Plasma_client] |
Lists the contents of the directory, given by inode
|
| list_inode_e [Plasma_client] | |
| local_filesystem [Mapred_fs] | local_filesystem root: Access the local filesystem where the
directory root is the assumed root.
|
| local_identities [Plasma_client] |
Return the identities of the data nodes running on this machine
(for
configure_pref_nodes)
|
| local_identities_e [Plasma_client] | |
| location [Mapred_toolkit.Place] | |
| lock_name_of_task_id [Mapred_tasks] |
The name used for forming the name of the lock files
|
| lookup [Pkv_api] | lookup db key: Looks this key up, and returns it.
|
| lookup [Mapred_rfun] |
Returns a registered function
|
| lookup [Nn_dentrycache] | lookup dir_inode name: Looks up the name in the cache, or raises
Not_found
|
| lookup [Nn_inodecache] |
Looks up the inode in the cache, or raises
Not_found
|
| lookup [Plasma_client] |
Looks the absolute filename up and returns the inode number
|
| lookup_buffer [Plasma_filebuf] | lookup_buffer sys inode index: Looks the buffer up for inode
and index, or raises Not_found if there is none yet, or
the existing descriptor is in `Dropped state.
|
| lookup_e [Plasma_client] | |
| lookup_large [Pkv_api] | lookup_large db key buf f: If the key is found, the function f
is called with the size of the value.
|
| lookup_large_e [Pkv_api] |
Same as asynchronous function
|
M | |
| main [Mapred_main] |
Main program for the task server and job controller, for this
single job only
|
| map [Mapred_toolkit.Seq] | let s3 = map f s1 s2: Maps the elements of s1 and adds them
to s2
|
| map [Nn_blocklist] | map f blist: Returns a blocklist where each element is mapped
via f
|
| mapl [Mapred_toolkit.DSeq] | mapl m pl_in pl_out conf: Runs a map-only job.
|
| mapl [Mapred_toolkit.Seq] | let s3 = map f s1 s2: Maps the elements of s1 to lists and adds them
to s2
|
| mapl_sort_fold [Mapred_toolkit.DSeq] | mapl_sort_fold <args> pl_in pl_out conf int_codec: This is
map/reduce.
|
| mapl_sort_fold [Mapred_toolkit.Seq] | mapl_sort_fold ... p_in p_out:
|
| mapred_job_config [Mapred_job_config] |
Returns the config as object
|
| mark_as_finished [Mapred_sched] |
Marks this task as finished
|
| mark_as_started [Mapred_sched] |
Marks this task as started, together with the node where it is running,
and the runtime task ID and the misallocation flag
|
| marshal [Mapred_job_config] | |
| max_key_size [Pkv_api] |
Return the maximum key size
|
| max_time [Plasma_filebuf] |
The max of two time structs
|
| mem_size [Plasma_filebuf] |
size of buffers in bytes
|
| merge [Nn_blocklist] | merge blist1 blist2: Merges both blocklists.
|
| merge_sort [Mapred_sort] | |
| message [Mapred_job_exec] |
Logs a message
|
| message_rjc [Mapred_job_exec] | |
| mkdir [Plasma_client] |
Creates a directory
|
| mkdir_e [Plasma_client] | |
| monitor_e [Nn_commit_monitor] | monitor_e cm uc f:
Tries to get a slot for doing a commit described by uc.
|
| multi_read_e [Plasma_client] | multi_read_e c inode stream: This version of read allows it
to read multiple times from the same file.
|
| multi_tree [Mapred_fs] | multi_tree trees default_tree:
|
N | |
| n_finished [Mapred_sched] | |
| n_running [Mapred_sched] | |
| n_total [Mapred_sched] |
Stats of tasks
|
| n_waiting [Plasma_filebuf] |
The number of buffer requests that can be currently not satisfied
|
| namelock [Plasma_client] | namelock trans dir name: Acquires an existence lock on the member
name of directory dir.
|
| namelock_e [Plasma_client] | |
| names_count_e [Nn_db] |
Count names of an inode
|
| names_count_ro_e [Nn_db] |
same, using an ro transaction
|
| names_del_e [Nn_db] |
Delete this name
|
| names_get_e [Nn_db] |
Look up inode by dir_inode and name
|
| names_get_parent_e [Nn_db] |
Look up the parent inode of an inode.
|
| names_get_parent_ro_e [Nn_db] |
same, using an ro transaction
|
| names_get_ro_e [Nn_db] |
same, using an ro transaction
|
| names_ins_e [Nn_db] |
Insert this name to inode mapping
|
| names_list_e [Nn_db] |
Lists the contents of the directory identified by
dir_inode.
|
| names_list_ro_e [Nn_db] |
same, using an ro transaction
|
| names_rev_get_e [Nn_db] |
Look up names by inode.
|
| names_rev_get_ro_e [Nn_db] |
same, using an ro transaction
|
| netfs [Plasma_netfs] |
Access this cluster with the
stream_fs interface:
|
| new_ticket_verifier [Nn_datanode_ctrl] | |
| newer_version_available [Pkv_api] |
In transactional mode, this function checks whether a concurrent
writer has committed a new version in the meantime.
|
| newer_version_available_e [Pkv_api] |
Same as async function
|
| next_lf [Platform.Line_splitter] |
Looks for the next LF char.
|
| notebook [Mapred_toolkit.Seq] |
creates an in-memory sequence (not linked to a file)
|
| notebook [Mapred_toolkit.Store] |
Creates a new in-memory store.
|
| notebook_place [Mapred_toolkit.Place] |
A new in-memory place for notebooks
|
| notify_got_eio [Plasma_inodecache] |
We got an EIO and have to update the blocklist.
|
| null_datastore [Nn_datastores] | |
| null_sorter [Mapred_sorters] |
This "sorter" just copies the input unmodified to the output
|
| number_cores [Platform] |
Returns the number of cores (or virtual cores) on the system.
|
O | |
| of_list [Mapred_stats] | |
| of_xdr [Nn_datastores] |
Convert
datastore to/from the wire representation
|
| open_cluster [Plasma_client] | open_cluster name namenodes: Opens the cluster with these namenodes
(given as (hostname,port) pairs).
|
| open_cluster_cc [Plasma_client] |
Same, but takes a
Plasma_client_config.client_config object which
can in turn be obtained via Plasma_client_config.get_config.
|
| open_cluster_like [Plasma_client] |
Opens a cluster with a configuration taken from an existing cluster.
|
| open_store [Dn_store] |
Opens the store
|
| opendb [Pkv_api] | opendb c basename flags: Opens the database using the client c.
|
| opendb_e [Pkv_api] |
Almost the same as async function.
|
| openshm [Dn_shm] |
Maps the shm object
|
| override_blocks [Plasma_inodecache] | override_blocks blc block n blocklist:
Puts these blocks into the cache, overriding whatever is there.
|
P | |
| p4_new_file [Mapred_rfun] |
Used in
mapred.mlp to announce a new source file
|
| p4_register [Mapred_rfun] |
Used in
mapred.mlp to register a function with an automatic name
|
| params [Plasma_client] |
Returns a list of client parameters
|
| params_e [Plasma_client] | |
| parse_config_file [Plasma_client_config] |
Parses the config file and returns all included configs
|
| parse_ug_admin [Plasma_ug] |
Parses the admin tables passed as argument (as pairs
(table_name,table_contents)).
|
| physical_ram [Platform] |
Tries to get the amount of physical RAM, in bytes.
|
| pipe_file [Pfs_condition] |
The name of the named pipe
|
| place [Mapred_toolkit.Store] |
returns the place where this store resides
|
| plan_complete [Mapred_sched] |
Respond whether everything is planned
|
| plan_finished [Mapred_sched] |
Whether everything is done
|
| planning_capacity [Mapred_job_exec] |
The total capacity of all machines (for planning)
|
| plasma_filesystem [Mapred_fs] | plasma_filesystem cc configure:
|
| post_add_hook [Nn_monitor] |
Needs to be called from the
post_add_hook
|
| post_add_hook [Nn_datastore_news] |
Needs to be called from the
post_add_hook
|
| post_add_hook [Plasma_shm.Netplex_shm_manager] |
This function must be called from the
post_add_hook of the
component
|
| post_start_hook [Nn_monitor] |
Reads the datastore table from the database, and starts discovering
datanodes.
|
| post_start_hook [Nn_slave] | |
| post_start_hook [Nn_coord] | post_start_hook cont conf cauth pool master_index transaction_revision
|
| post_start_hook [Nn_datanode_ctrl] | post_start_hook pool cauth
|
| post_start_hook [Nn_dentrycache] | pool
|
| post_start_hook [Nn_inodecache] | pool
|
| post_start_hook [Nn_authticket] | pool
|
| post_start_hook [Nn_ug] | pool
|
| prepare_commit_e [Nn_push] |
Prepares the commit.
|
| principal [Nn_authticket] |
Describe the principal behind the ticket as pair
(pw_entry, main_group, groups).
|
| principal_of_auth_ticket [Plasma_ug] |
Returns
(user,group,supp_groups)
|
| print_file [Mapred_tasks] | |
| print_plan [Mapred_sched] |
Debug printing to stdout
|
| print_task [Mapred_tasks] | |
| print_task_id [Mapred_tasks] | |
| privileged_user [Pfs_auth] |
The name of the privileged users: "proot" (Plasma root)
|
| push_e [Nn_push] |
Pushes the db modification to the slave which the client connects
to
|
R | |
| random_bytes [Plasma_rng] |
Returns a string with n random bytes
|
| random_int [Plasma_rng] |
Returns a random int 0 ..
|
| random_int64 [Plasma_rng] |
Returns a random int64 number
|
| read [Mapred_toolkit.Seq] |
Returns the sequence view such that the first element of the sequence
is the first element of the store, i.e.
|
| read [Mapred_toolkit.Store] |
Returns another store value reading the data from the same
physical place.
|
| read [Mapred_io_bgreader] | read bgreader: reads the next blocks into the buffer.
|
| read [Plasma_client] | read_e c inode pos s spos len: Reads data from inode, and returns
(n,eof,ii) where n is the number of read bytes, and eof the indicator
that EOF was reached.
|
| read_admin_table [Plasma_client] | read_admin_table_e key Returns the admin table key as text.
|
| read_admin_table_e [Plasma_client] | |
| read_block [Dn_store] | read_block st block blockpos mem mpos len: Reads the bytes
blockpos to blockpos+len-1 from block into the range
mpos to mpos+len-1 of mem.
|
| read_e [Plasma_client] | |
| read_multiple [Mapred_io] |
Constructs a record reader that reads from the input
readers one
after the other.
|
| read_place [Mapred_toolkit.Store] |
Returns the stores at one place.
|
| read_ug_admin [Plasma_client] |
Read the admin tables for managing users and groups, and make the
contents available as
Plasma_ug.ug_admin object.
|
| read_ug_admin_e [Nn_db] | |
| read_ug_admin_e [Plasma_client] | |
| receive_message [Nn_monitor] |
Needs to be called from the
receive_message hook in order to
arrange notifications about db updates
|
| receive_message [Nn_datastore_news] |
Needs to be called from the
receive_message hook in order to
subscribe to this news channel
|
| register [Mapred_rfun] | register name f: Registers the function f under name.
|
| register_file [Pfs_pmanage] |
Register a temporary file
|
| register_shm [Pfs_pmanage] |
Register a POSIX shm object
|
| regular_ii [Plasma_client] | regular_ii c mode: Creates an inodeinfo record for a new empty
regular file, where the mode field is set to mode modulo
the current mask
|
| release_flush_request [Plasma_filebuf] |
Checks whether the buffers are in the right state after finishing
or aborting a flush request.
|
| remove [Nn_blocklist] | remove (min,max) blist: Returns the blocklist where the interval
(min,max) is deleted
|
| remove_marks [Mapred_sched] |
Revokes
mark_as_started or mark_as_finished
|
| rename [Plasma_client] | rename trans old_path new_path: Renames/moves the file or directory
identified by old_path to the location identified by new_path.
|
| rename_at [Plasma_client] | rename_at trans old_dir_inode old_name new_dir_inode new_name:
Moves the file old_name in old_dir_inode to the new location
which is given by new_name in new_dir_inode.
|
| rename_at_e [Plasma_client] | |
| rename_e [Plasma_client] | |
| renew [Nn_authticket] |
Renew the ticket.
|
| reopen [Pkv_api] |
Re-opens the db after
commit or abort
|
| reopen_e [Pkv_api] |
Same as async function
|
| req_admin_tables [Plasma_ug] |
Which admin tables are required (normally "passwd" and "group",
but in the future more such tables could be defined)
|
| request_buffer_e [Plasma_filebuf] | request_buffer_e sys inode index: This function is to be used
when lookup_buffer raises Not_found to get a new buffer.
|
| reread [Mapred_toolkit.Seq] |
reads the elements from the store obtained by calling
Store.read
|
| reset [Nn_datanode_ctrl] |
Executes a ticket reset in the background
|
| reset_inode_error [Plasma_filebuf] |
Resets the error
|
| retry [Plasma_client] | retry c name f arg: Executes f arg and returns the result.
|
| retry_e [Plasma_client] | |
| rev_find_lf [Platform] |
Looks for the last LF char from
mem[pos] to mem[endpos-1] and returns
the position.
|
| rev_lookup [Plasma_client] |
Returns the filenames linked with this inode number.
|
| rev_lookup_dir [Plasma_client] |
Returns the abs filename linked with this inode number which must be
a directory.
|
| rev_lookup_dir_e [Plasma_client] | |
| rev_lookup_e [Plasma_client] | |
| revision_clear_e [Nn_db] |
Deletes all revisions
|
| revision_get_checksum_e [Nn_db] |
Get the checksum of all revision strings
|
| revision_get_e [Nn_db] |
Get the maximum revision string
|
| revision_get_ro_e [Nn_db] |
same, using an ro transaction
|
| revision_transaction_e [Nn_coord] |
This initial transaction clears all revisions.
|
| revision_upd_e [Nn_db] |
Inserts or updates the revision string of a committer
|
| ro_esys [Nn_db] |
Returns the esys for ro transactions
|
| ro_transact [Nn_db] |
Same for read-only transactions.
|
| root_page [Pkv_xdr_aux] | |
| round_points [Mapred_sched] |
Returns points for the task, such that tasks in later rounds get
more points than tasks in earlier rounds.
|
| rpc_login_of_auth_ticket [Plasma_ug] |
Returns
(rpc_user,rpc_password)
|
| rpc_proxy_auth_methods [Mapred_auth] |
Returns a value suitable for the
mclient_auth_methods field.
|
| rpc_proxy_auth_methods [Pfs_auth] |
Returns a value suitable for the
mclient_auth_methods field.
|
| run [Mapred_job] |
Run the tasks, and wait until the job is done
|
S | |
| scan_dir [Mapred_io] | scan_dir fs dir deeply: Scans the directory dir for files,
and returns the files (w/o directory prefix) as pairs
(name,info).
|
| scan_file [Mapred_io] |
Returns information about this file
|
| schedule_drop [Plasma_filebuf] |
If the buffer can be immediately invalidated this is done.
|
| schedule_drop_inode [Plasma_filebuf] |
Same for a whole inode.
|
| scp_taskfile_manager [Mapred_taskfiles] |
A taskfile manager that uses
scp to copy file to remote nodes.
|
| scp_to_cmd [Mapred_taskfiles] | scp_to_cmd localfiles host dest: Generates a shell command that
copies localfiles to host into the destination dest
|
| select_for_flush [Plasma_filebuf] | select_for_flush sys inode: Returns a list of blocks that need
to be written.
|
| select_inodes [Plasma_filebuf] |
Returns the inodes that can be flushed, in the order of precedence.
|
| serialize_auth_ticket [Plasma_ug] | |
| serializer [Pfs_condition] | serializer heap esys:
Creates a serializer that works across processes.
|
| serializer_heap [Pfs_condition] | serializer_heap pool: initializes a shared structure for use with
serializer.
|
| serve [Nn_blockmap_box] |
Make this process a blockmap server.
|
| set_inodeinfo [Plasma_client] |
set info about inode.
|
| set_inodeinfo_e [Plasma_client] | |
| set_ug_files [Nn_ug] |
Set the current version of the user/group tables.
|
| setup [Nn_slave] | |
| setup [Nn_coord] | |
| setup_elect_api [Nn_elect] |
Set up the RPC server so that
Elect procedures are bound
|
| sh_state_shm [Nn_state] | |
| shm_limit [Platform] |
Returns a limit on the amount of POSIX shm.
|
| shm_manager [Plasma_client] |
Returns the current manager
|
| shutdown [Nn_monitor] |
To be called at shutdown time
|
| signal [Pfs_condition] | signal c restarts one of the processes waiting on the
condition variable c.
|
| signal_db_change [Nn_datastore_news] | signal_db_change id node_opt: Signal to the monitor that
the db row with id has changed and must be reread.
|
| slot [Dn_shm] | let (mem,pos) = slot shm i: Accesses the slot i of the shm
object shm.
|
| snapshot [Plasma_client] | snapshot trans inode: Takes a snapshot of the file, affecting
buffered reads and writes, and a few other functions.
|
| snapshot_blocks_e [Plasma_inodecache] |
Loads the complete blocklist - which effectively means to take a
snapshot of the whole file.
|
| snapshot_e [Plasma_client] | |
| sort [Mapred_toolkit.Seq] | sort ~hash ~cmp s1 s2: Sorts the elements of s1 and appends
the sorted result to s2, and returns this sequence.
|
| ssh_cmd [Mapred_taskfiles] | ssh_cmd host cmd: Generates a shell command that runs cmd on
host
|
| standard_fs [Mapred_fs] | standard_fs conf: Returns the standard filesystem that is used
for map/red jobs.
|
| standard_fs_cc [Mapred_fs] |
Another version of
standard_fs: If client_config is passed,
PlasmaFS will be enabled, otherwise disabled.
|
| start [Mapred_job_exec] |
Starts the job which is running asynchronously with the event system
|
| start [Plasma_client] |
Starts a transaction
|
| start_e [Plasma_client] | |
| start_publishing [Nn_monitor] |
Updates on the datastores are published and can be retrieved from
any other process using
Nn_datastore_news
|
| stats [Mapred_toolkit.DSeq] |
Get statistics
|
| stats [Mapred_job_exec] | |
| status [Mapred_job_exec] | |
| stop [Platform.Line_splitter] |
Stops the thread.
|
| stop_election [Nn_elect] |
Stops any ongoing election (in the current process only)
|
| stop_election_msg [Nn_elect] |
The name of a parameterless message for
stop_election.
|
| store [Mapred_toolkit.Seq] |
The underlying store of the sequence
|
| str_cmp [Platform] | str_cmp s1 p1 l1 s2 p2 l2: The same as
String.compare (String.sub s1 p1 l1) (String.sub s2 p2 l2), only
faster
|
| str_cmp_unsafe [Platform] |
See
str_cmp
|
| string_of_counter_name [Nn_state] | |
| string_of_level [Pfs_auth] | |
| string_of_owner [Nn_state] | |
| string_of_owner [Nn_blockmap] |
debug string
|
| string_of_role [Nn_elect] | |
| string_of_task_id [Mapred_tasks] | |
| string_of_trl [Nn_blockmap] |
For debugging
|
| sub [Nn_blocklist] | sub (min,max) blist: Returns the blocklist with the subset of
blist that intersects with the interval (min,max)
|
| switch_to_reading [Plasma_filebuf] | switch_to_reading sys b e eof_opt:
|
| switch_to_writing [Plasma_filebuf] |
The buffer is switched to
`Writing state (from `Dirty).
|
| symlink_ii [Plasma_client] | regular_ii c target: Creates an inodeinfo record for a symlink
pointing to target
|
| sync [Dn_store] |
Syncs the store to disk
|
| sync [Plasma_client] |
Waits until the event system is done and returns the result of the
engine
|
| sys_is_darwin [Plasma_platform] |
Whether we are running on Darwin (OS X)
|
T | |
| tab2_get_partition [Mapred_split] |
Returns the partition of a string "<key> TAB <partition>"
|
| tab2_split [Mapred_split] |
Splits a line into (key, partition, value).
|
| tab2_split_key [Mapred_split] |
Same as
let (key,_,_) = tab2_split s in key
|
| tab2_split_key_partition [Mapred_split] |
Same as
let (key,p,_) = tab2_split s in (key,p)
|
| tab2_split_key_partition_range [Mapred_split] |
Returns the range of the key and the partition
|
| tab2_split_key_range [Mapred_split] |
Returns only the range of the key
|
| tab_split [Mapred_split] |
Splits a line into key and value.
|
| tab_split_key [Mapred_split] |
Same as
fst (tab_split_key s)
|
| tab_split_key_range [Mapred_split] |
Returns only the range of the key
|
| task_depends_on_list [Mapred_sched] |
Returns the list of tasks a given task depends on
|
| task_stats [Mapred_sched] |
Returns: number of input files, number of non-local input files
Raise
Not_found if the task has never been started
|
| test_config [Mapred_config] | |
| test_job_config [Mapred_job_config] |
Returns a test object
|
| text_field [Mapred_fields] |
Like
text_field_range, but returns the contents and not the range
|
| text_field_range [Mapred_fields] | let (p,l) = text_field_range s: Extracts a field from s, and returns
in p the byte position where the field begins, and in l the
byte length.
|
| text_fields [Mapred_fields] |
Like
text_field_range, but returns the contents of each field
|
| text_fields_range [Mapred_fields] |
Like
text_field_range, but returns the ranges (p,l) for each
field separately
|
| tl [Mapred_toolkit.Seq] |
returns the tail of the sequence
|
| to_blockinfo_list [Nn_blocklist] |
Returns the blocks for a blocklist
|
| to_blocklist [Nn_blocklist] |
Converts any list of blocks to the official
blocklist representation
|
| to_group [Plasma_opendir] | |
| to_list [Mapred_stats] | |
| to_passwd [Plasma_opendir] | |
| to_string [Nn_blocklist] |
String repr for debugging
|
| to_xdr [Nn_datastores] | |
| toolkit_job [Mapred_toolkit] |
This is a generic job definition that must be used together with
the distributed algorithms in
Mapred_toolkit.DSeq.
|
| trans_e [Nn_commit] | let e' = trans_e sh vl e debug_name: Runs the engine e until
it is finished,
and if e was successful, the modifications of the views vl
are taken as the modifications to be done in the transaction,
and the transaction is committed.
|
| transact [Nn_db] |
Finds an unused connection, and start a transaction.
|
| trigger_shutdown [Nn_push] |
Triggers the shutdown of this client
|
| truncate [Plasma_client] |
Sets EOF value, and all blocks beyond EOF are deallocated.
|
| truncate_e [Plasma_client] | |
U | |
| unescape [Mapred_fields] |
Encode bytes that cannot be directly put into text fields with
escape sequences
|
| unlink [Dn_shm] |
Unlinks the name.
|
| unlink [Plasma_client] |
Unlinks the name.
|
| unlink_at [Plasma_client] | unlink_at trans dir_inode name: Removes the entry name from
the directory dir_inode.
|
| unlink_at_e [Plasma_client] | |
| unlink_e [Plasma_client] | |
| unmarshal [Mapred_job_config] |
Marshal and unmarshal
|
| update [Nn_dentrycache] |
Updates the cache with this info
|
| update [Nn_inodecache] |
Updates the inode with this inodeinfo
|
| update_allocinfo [Nn_db] | update_allocinfo inode ailist bilist: Returns a hash table ht
which maps each datanode identity to the selected allocinfo block.
|
| update_from_db [Nn_monitor] |
Read the db version of this record, and trigger the update of the
module copy of it.
|
| update_job_config [Mapred_job_config] |
Updates the values that are actually passed as arguments
|
V | |
| vacuum [Pkv_api] |
Garbage-collects the db.
|
| var_concat [Mapred_fields] |
Returns a string with the encoded fields
|
| var_field [Mapred_fields] |
Like
var_field_range, but returns the contents and not the range
|
| var_field_range [Mapred_fields] | let (p,l) = var_field_range s: Extracts a field from s, and returns
in p the byte position where the field begins, and in l the
byte length.
|
| var_fields [Mapred_fields] |
Like
var_field_range, but returns the contents of each field
|
| var_fields_range [Mapred_fields] |
Like
var_field_range, but returns the ranges (p,l) for each
field separately
|
| var_size_format [Mapred_io] |
A record consists of a variable number of bytes (at most a bigblock).
|
| verifier_of_auth_ticket [Plasma_ug] |
Returns
(verifier)
|
W | |
| wait_e [Pfs_condition] | wait_e we c m esys cont atomically unlocks the mutex m and suspends the
calling engine on the condition variable c.
|
| wait_until_ready_e [Nn_push] |
Busy-waits until the nameslave program is available
|
| wait_until_slaves_are_ready_e [Nn_coord] |
Wait until the slaves respond
|
| will_read_block [Dn_store] | will_read_block st block: announces that this block will be read
in the near future
|
| with_ro_trans [Nn_db] | with_ro_trans f: Runs e = f conn esys for a shared read-only
transaction and returns e
|
| with_trans [Plasma_client] | with_trans c f: Starts a new transaction t and runs f t.
|
| with_trans_e [Plasma_client] | |
| write [Plasma_client] | write_e c inode pos s spos len: Writes data to inode and returns
the number of written bytes.
|
| write_admin_table [Plasma_client] | write_admin_table_e key file: Sets the admin table key to file.
|
| write_admin_table_e [Plasma_client] | |
| write_block [Dn_store] | write_block st block blockpos mem mpos: Writes a complete block out.
|
| write_cancelled [Plasma_filebuf] |
The write is cancelled.
|
| write_committed [Plasma_filebuf] |
Records that the write is committed: If the buffer is in
`Written false state it is reset to `Clean (or reassigned for
a different purpose).
|
| write_e [Plasma_client] | |
| write_erroneous [Plasma_filebuf] |
Records a write error.
|
| write_multiple [Mapred_io] | write_multiple fs shm rc prefix size_limit lines_limit create_sync create_async rwf:
Writes into a sequence of files
whose names are composed of prefix followed by an integer k.
|
| write_place [Mapred_toolkit.Store] |
Returns a new store with an automatically generated name.
|
| write_ug_admin [Plasma_client] |
Write the admin tables back (after modification)
|
| write_ug_admin_e [Plasma_client] | |
X | |
| x_netfs [Plasma_netfs] | |
| xdrt_int_page [Pkv_xdr_aux] | |
| xdrt_key [Pkv_xdr_aux] | |
| xdrt_key_p [Pkv_xdr_aux] | |
| xdrt_leaf_page [Pkv_xdr_aux] | |
| xdrt_page [Pkv_xdr_aux] | |
| xdrt_page_type [Pkv_xdr_aux] | |
| xdrt_root_page [Pkv_xdr_aux] |
