-/* Copyright (c) 2004, 2005, 2006, 2007, 2008, 2009, 2010. The SimGrid Team.
+/* Copyright (c) 2004-2013. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
#include "xbt/lib.h"
#include "surf/surf_routing.h"
#include "simgrid/platf_interface.h"
+#include "simgrid/datatypes.h"
SG_BEGIN_DECL()
/* Actions and models are highly connected structures... */
class Model;
class CpuModel;
class WorkstationModel;
-class NetworkCm02Model;
+class WorkstationVMModel;
+class NetworkModel;
+class StorageModel;
class Resource;
class ResourceLmm;
class WorkstationCLM03;
class Action;
class ActionLmm;
class StorageActionLmm;
-class As;
-class RoutingEdge;
+struct As;
+struct RoutingEdge;
class RoutingPlatf;
#else
typedef struct Model Model;
typedef struct CpuModel CpuModel;
typedef struct WorkstationModel WorkstationModel;
-typedef struct NetworkCm02Model NetworkCm02Model;
+typedef struct WorkstationVMModel WorkstationVMModel;
+typedef struct NetworkModel NetworkModel;
+typedef struct StorageModel StorageModel;
typedef struct Resource Resource;
typedef struct ResourceLmm ResourceLmm;
typedef struct WorkstationCLM03 WorkstationCLM03;
typedef Model *surf_model_t;
typedef CpuModel *surf_cpu_model_t;
typedef WorkstationModel *surf_workstation_model_t;
-typedef NetworkCm02Model *surf_network_model_t;
+typedef WorkstationVMModel *surf_vm_workstation_model_t;
-typedef Resource *surf_resource_t;
-typedef ResourceLmm *surf_resource_lmm_t;
+typedef NetworkModel *surf_network_model_t;
+typedef StorageModel *surf_storage_model_t;
+
+typedef xbt_dictelm_t surf_resource_t;
+typedef Resource *surf_cpp_resource_t;
typedef WorkstationCLM03 *surf_workstation_CLM03_t;
-typedef xbt_dictelm_t surf_workstation_t;
typedef NetworkCm02Link *surf_network_link_t;
typedef Cpu *surf_cpu_t;
XBT_PUBLIC(void) model_help(const char *category,
s_surf_model_description_t * table);
-
-
/** \ingroup SURF_actions
* \brief Action states
*
/**< Not in the system anymore. Why did you ask ? */
} e_surf_action_state_t;
+/* FIXME: Where should the VM state be defined? */
+typedef enum {
+ /* created, but not yet started */
+ SURF_VM_STATE_CREATED,
+
+ SURF_VM_STATE_RUNNING,
+ SURF_VM_STATE_MIGRATING,
+
+ /* Suspend/resume does not involve disk I/O, so we assume there is no transition states. */
+ SURF_VM_STATE_SUSPENDED,
+
+ /* Save/restore involves disk I/O, so there should be transition states. */
+ SURF_VM_STATE_SAVING,
+ SURF_VM_STATE_SAVED,
+ SURF_VM_STATE_RESTORING,
+
+} e_surf_vm_state_t;
+
/***************************/
/* Generic model object */
/***************************/
//FIXME:REMOVE typedef struct s_routing_platf s_routing_platf_t, *routing_platf_t;
XBT_PUBLIC_DATA(routing_platf_t) routing_platf;
-/*******************************************
- * TUTORIAL: New model
- * New model extension public
- * Public functions specific to a New model.
- */
-typedef struct surf_new_model_extension_public {
- surf_action_t(*fct) ();
- void* (*create_resource) ();
-} s_surf_model_extension_new_model_t;
-/*******************************************/
-
-/** \ingroup SURF_models
- * \brief Private data available on all models
- */
-typedef struct surf_model_private *surf_model_private_t;
-
- /* Cpu model */
-
- /** \ingroup SURF_models
- * \brief CPU model extension public
- *
- * Public functions specific to the CPU model.
- */
-typedef struct surf_cpu_model_extension_public {
- surf_action_t(*execute) (void *cpu, double size);
- surf_action_t(*sleep) (void *cpu, double duration);
- e_surf_resource_state_t(*get_state) (void *cpu);
- int (*get_core) (void *cpu);
- double (*get_speed) (void *cpu, double load);
- double (*get_available_speed) (void *cpu);
- void (*add_traces) (void);
-} s_surf_model_extension_cpu_t;
-
- /* Network model */
-
- /** \ingroup SURF_models
- * \brief Network model extension public
- *
- * Public functions specific to the network model
- */
-typedef struct surf_network_model_extension_public {
- surf_action_t (*communicate) (sg_routing_edge_t src,
- sg_routing_edge_t dst,
- double size, double rate);
- xbt_dynar_t(*get_route) (void *src, void *dst); //FIXME: kill field? That is done by the routing nowadays
- double (*get_link_bandwidth) (const void *link);
- double (*get_link_latency) (const void *link);
- int (*link_shared) (const void *link);
- void (*add_traces) (void);
-} s_surf_model_extension_network_t;
-
-/* Storage model */
-//
-/** \ingroup SURF_models
- * \brief Storage model extension public
- *
- * Public functions specific to the Storage model.
- */
-
-typedef struct surf_storage_model_extension_public {
- surf_action_t(*open) (void *storage, const char* mount, const char* path);
- surf_action_t(*close) (void *storage, surf_file_t fd);
- surf_action_t(*read) (void *storage, void* ptr, size_t size,
- surf_file_t fd);
- surf_action_t(*write) (void *storage, const void* ptr, size_t size,
- surf_file_t fd);
- surf_action_t(*stat) (void *storage, surf_file_t fd);
- surf_action_t(*ls) (void *storage, const char *path);
-} s_surf_model_extension_storage_t;
-
- /** \ingroup SURF_models
- * \brief Workstation model extension public
- *
- * Public functions specific to the workstation model.
- */
-typedef struct surf_workstation_model_extension_public {
- surf_action_t(*execute) (void *workstation, double size); /**< Execute a computation amount on a workstation
- and create the corresponding action */
- surf_action_t(*sleep) (void *workstation, double duration); /**< Make a workstation sleep during a given duration */
- e_surf_resource_state_t(*get_state) (void *workstation); /**< Return the CPU state of a workstation */
- int (*get_core) (void *workstation);
- double (*get_speed) (void *workstation, double load); /**< Return the speed of a workstation */
- double (*get_available_speed) (void *workstation); /**< Return tha available speed of a workstation */
- surf_action_t(*communicate) (void *workstation_src, /**< Execute a communication amount between two workstations */
- void *workstation_dst, double size,
- double max_rate);
- // FIXME: kill next field, which duplicates the routing
- xbt_dynar_t(*get_route) (void *workstation_src, void *workstation_dst); /**< Get the list of links between two ws */
-
- surf_action_t(*execute_parallel_task) (int workstation_nb, /**< Execute a parallel task on several workstations */
- void **workstation_list,
- double *computation_amount,
- double *communication_amount,
- double rate);
- double (*get_link_bandwidth) (const void *link); /**< Return the current bandwidth of a network link */
- double (*get_link_latency) (const void *link); /**< Return the current latency of a network link */
- surf_action_t(*open) (void *workstation, const char* storage,
- const char* path);
- surf_action_t(*close) (void *workstation, surf_file_t fd);
- surf_action_t(*read) (void *workstation, void* ptr, size_t size,
- surf_file_t fd);
- surf_action_t(*write) (void *workstation, const void* ptr, size_t size,
- surf_file_t fd);
- surf_action_t(*stat) (void *workstation, surf_file_t fd);
- int(*unlink) (void *workstation, surf_file_t fd);
- surf_action_t(*ls) (void *workstation, const char* mount, const char *path);
- size_t (*get_size) (void *workstation, surf_file_t fd);
-
- int (*link_shared) (const void *link);
- xbt_dict_t(*get_properties) (const void *resource);
- void (*add_traces) (void);
-
-} s_surf_model_extension_workstation_t;
-
-
static inline void *surf_cpu_resource_priv(const void *host) {
return xbt_lib_get_level((xbt_dictelm_t)host, SURF_CPU_LEVEL);
}
static inline void *surf_workstation_resource_priv(const void *host){
return (void*)xbt_lib_get_level((xbt_dictelm_t)host, SURF_WKS_LEVEL);
}
-static inline void *surf_storage_resource_priv(const void *host){
- return (void*)xbt_lib_get_level((xbt_dictelm_t)host, SURF_STORAGE_LEVEL);
+static inline void *surf_storage_resource_priv(const void *storage){
+ return (void*)xbt_lib_get_level((xbt_dictelm_t)storage, SURF_STORAGE_LEVEL);
}
static inline void *surf_cpu_resource_by_name(const char *name) {
return xbt_lib_get_elm_or_null(storage_lib, name);
}
-#ifdef __cplusplus
-extern "C" {
-#endif
-char *surf_routing_edge_name(sg_routing_edge_t edge);
-
-const char *surf_model_name(surf_model_t model);
-xbt_swag_t surf_model_done_action_set(surf_model_t model);
-xbt_swag_t surf_model_failed_action_set(surf_model_t model);
-xbt_swag_t surf_model_ready_action_set(surf_model_t model);
-xbt_swag_t surf_model_running_action_set(surf_model_t model);
-surf_action_t surf_workstation_model_execute_parallel_task(surf_workstation_model_t model,
+XBT_PUBLIC(char *) surf_routing_edge_name(sg_routing_edge_t edge);
+XBT_PUBLIC(void *) surf_as_cluster_get_backbone(AS_t as);
+XBT_PUBLIC(void) surf_as_cluster_set_backbone(AS_t as, void* backbone);
+XBT_PUBLIC(const char *) surf_model_name(surf_model_t model);
+XBT_PUBLIC(xbt_swag_t) surf_model_done_action_set(surf_model_t model);
+XBT_PUBLIC(xbt_swag_t) surf_model_failed_action_set(surf_model_t model);
+XBT_PUBLIC(xbt_swag_t) surf_model_ready_action_set(surf_model_t model);
+XBT_PUBLIC(xbt_swag_t) surf_model_running_action_set(surf_model_t model);
+XBT_PUBLIC(surf_action_t) surf_workstation_model_execute_parallel_task(surf_workstation_model_t model,
int workstation_nb,
void **workstation_list,
double *computation_amount,
double *communication_amount,
double rate);
-surf_action_t surf_workstation_model_communicate(surf_workstation_model_t model, surf_workstation_t src, surf_workstation_t dst, double size, double rate);
-xbt_dynar_t surf_workstation_model_get_route(surf_workstation_model_t model, surf_workstation_t src, surf_workstation_t dst);
-surf_action_t surf_network_model_communicate(surf_network_model_t model, sg_routing_edge_t src, sg_routing_edge_t dst, double size, double rate);
-const char *surf_resource_name(surf_resource_t resource);
-xbt_dict_t surf_resource_get_properties(surf_resource_t resource);
-e_surf_resource_state_t surf_resource_get_state(surf_resource_t resource);
-double surf_workstation_get_speed(surf_workstation_t resource, double load);
-double surf_workstation_get_available_speed(surf_workstation_t resource);
-int surf_workstation_get_core(surf_workstation_t resource);
-surf_action_t surf_workstation_execute(surf_workstation_t resource, double size);
-surf_action_t surf_workstation_sleep(surf_workstation_t resource, double duration);
-surf_action_t surf_workstation_open(surf_workstation_t workstation, const char* mount, const char* path);
-surf_action_t surf_workstation_close(surf_workstation_t workstation, surf_file_t fd);
-const char *surf_cpu_name(surf_cpu_t resource);
-surf_action_t surf_cpu_execute(surf_cpu_t cpu, double size);
-surf_action_t surf_cpu_sleep(surf_cpu_t cpu, double duration);
-int surf_workstation_unlink(surf_workstation_t workstation, surf_file_t fd);
-surf_action_t surf_workstation_ls(surf_workstation_t workstation, const char* mount, const char *path);
-size_t surf_workstation_get_size(surf_workstation_t workstation, surf_file_t fd);
-surf_action_t surf_workstation_read(surf_workstation_t resource, void *ptr, size_t size, surf_file_t fd);
-surf_action_t surf_workstation_write(surf_workstation_t resource, const void *ptr, size_t size, surf_file_t fd);
-int surf_network_link_is_shared(surf_network_link_t link);
-double surf_network_link_get_bandwidth(surf_network_link_t link);
-double surf_network_link_get_latency(surf_network_link_t link);
-void *surf_action_get_data(surf_action_t action);
-void surf_action_set_data(surf_action_t action, void *data);
-void surf_action_unref(surf_action_t action);
-double surf_action_get_start_time(surf_action_t action);
-double surf_action_get_finish_time(surf_action_t action);
-double surf_action_get_remains(surf_action_t action);
-void surf_action_suspend(surf_action_t action);
-void surf_action_resume(surf_action_t action);
-void surf_action_cancel(surf_action_t action);
-void surf_action_set_priority(surf_action_t action, double priority);
-void surf_action_set_category(surf_action_t action, const char *category);
-e_surf_action_state_t surf_action_get_state(surf_action_t action);
-int surf_action_get_cost(surf_action_t action);
-surf_file_t surf_storage_action_get_file(surf_storage_action_lmm_t action);
-xbt_dict_t surf_storage_action_get_ls_dict(surf_storage_action_lmm_t action);
-
-#ifdef __cplusplus
-}
-#endif
+XBT_PUBLIC(surf_action_t) surf_workstation_model_communicate(surf_workstation_model_t model, surf_resource_t src, surf_resource_t dst, double size, double rate);
+XBT_PUBLIC(xbt_dynar_t) surf_workstation_model_get_route(surf_workstation_model_t model, surf_resource_t src, surf_resource_t dst);
+XBT_PUBLIC(void) surf_vm_workstation_model_create(const char *name, surf_resource_t ind_phys_host);
+XBT_PUBLIC(surf_action_t) surf_network_model_communicate(surf_network_model_t model, sg_routing_edge_t src, sg_routing_edge_t dst, double size, double rate);
+XBT_PUBLIC(const char * ) surf_resource_name(surf_cpp_resource_t resource);
+XBT_PUBLIC(xbt_dict_t) surf_resource_get_properties(surf_cpp_resource_t resource);
+XBT_PUBLIC(e_surf_resource_state_t) surf_resource_get_state(surf_cpp_resource_t resource);
+XBT_PUBLIC(void) surf_resource_set_state(surf_cpp_resource_t resource, e_surf_resource_state_t state);
+XBT_PUBLIC(double) surf_workstation_get_speed(surf_resource_t resource, double load);
+XBT_PUBLIC(double) surf_workstation_get_available_speed(surf_resource_t resource);
+XBT_PUBLIC(int) surf_workstation_get_core(surf_resource_t resource);
+XBT_PUBLIC(surf_action_t) surf_workstation_execute(surf_resource_t resource, double size);
+XBT_PUBLIC(surf_action_t) surf_workstation_sleep(surf_resource_t resource, double duration);
+XBT_PUBLIC(surf_action_t) surf_workstation_open(surf_resource_t workstation, const char* mount, const char* path);
+XBT_PUBLIC(surf_action_t) surf_workstation_close(surf_resource_t workstation, surf_file_t fd);
+XBT_PUBLIC(surf_action_t) surf_workstation_read(surf_resource_t resource, surf_file_t fd, sg_size_t size);
+XBT_PUBLIC(surf_action_t) surf_workstation_write(surf_resource_t resource, surf_file_t fd, sg_size_t size);
+XBT_PUBLIC(xbt_dynar_t) surf_workstation_get_info(surf_resource_t resource, surf_file_t fd);
+XBT_PUBLIC(sg_size_t) surf_workstation_get_free_size(surf_resource_t resource, const char* name);
+XBT_PUBLIC(sg_size_t) surf_workstation_get_used_size(surf_resource_t resource, const char* name);
+XBT_PUBLIC(xbt_dynar_t) surf_workstation_get_vms(surf_resource_t resource);
+XBT_PUBLIC(void) surf_workstation_get_params(surf_resource_t resource, ws_params_t params);
+XBT_PUBLIC(void) surf_workstation_set_params(surf_resource_t resource, ws_params_t params);
+XBT_PUBLIC(void) surf_vm_workstation_destroy(surf_resource_t resource);
+XBT_PUBLIC(void) surf_vm_workstation_suspend(surf_resource_t resource);
+XBT_PUBLIC(void) surf_vm_workstation_resume(surf_resource_t resource);
+XBT_PUBLIC(void) surf_vm_workstation_save(surf_resource_t resource);
+XBT_PUBLIC(void) surf_vm_workstation_restore(surf_resource_t resource);
+XBT_PUBLIC(void) surf_vm_workstation_migrate(surf_resource_t resource, surf_resource_t ind_vm_ws_dest);
+XBT_PUBLIC(surf_resource_t) surf_vm_workstation_get_pm(surf_resource_t resource);
+XBT_PUBLIC(void) surf_vm_workstation_set_bound(surf_resource_t resource, double bound);
+XBT_PUBLIC(void) surf_vm_workstation_set_affinity(surf_resource_t resource, surf_resource_t cpu, unsigned long mask);
+XBT_PUBLIC(surf_action_t) surf_cpu_execute(surf_resource_t cpu, double size);
+XBT_PUBLIC(surf_action_t) surf_cpu_sleep(surf_resource_t cpu, double duration);
+XBT_PUBLIC(double) surf_workstation_get_current_power_peak(surf_resource_t host);
+XBT_PUBLIC(double) surf_workstation_get_power_peak_at(surf_resource_t host, int pstate_index);
+XBT_PUBLIC(int) surf_workstation_get_nb_pstates(surf_resource_t host);
+XBT_PUBLIC(void) surf_workstation_set_power_peak_at(surf_resource_t host, int pstate_index);
+XBT_PUBLIC(double) surf_workstation_get_consumed_energy(surf_resource_t host);
+XBT_PUBLIC(xbt_dict_t) surf_workstation_get_storage_list(surf_resource_t workstation);
+XBT_PUBLIC(int) surf_workstation_unlink(surf_resource_t workstation, surf_file_t fd);
+XBT_PUBLIC(surf_action_t) surf_workstation_ls(surf_resource_t workstation, const char* mount, const char *path);
+XBT_PUBLIC(size_t) surf_workstation_get_size(surf_resource_t workstation, surf_file_t fd);
+XBT_PUBLIC(size_t) surf_workstation_file_tell(surf_resource_t workstation, surf_file_t fd);
+XBT_PUBLIC(int) surf_workstation_file_seek(surf_resource_t workstation, surf_file_t fd, sg_size_t offset, int origin);
+XBT_PUBLIC(int) surf_network_link_is_shared(surf_cpp_resource_t link);
+XBT_PUBLIC(double) surf_network_link_get_bandwidth(surf_cpp_resource_t link);
+XBT_PUBLIC(double) surf_network_link_get_latency(surf_cpp_resource_t link);
+XBT_PUBLIC(xbt_dict_t) surf_storage_get_content(surf_resource_t resource);
+XBT_PUBLIC(sg_size_t) surf_storage_get_size(surf_resource_t resource);
+XBT_PUBLIC(void) surf_storage_rename(surf_resource_t resource, const char* src, const char* dest);
+XBT_PUBLIC(void*) surf_action_get_data(surf_action_t action);
+XBT_PUBLIC(void) surf_action_set_data(surf_action_t action, void *data);
+XBT_PUBLIC(void) surf_action_unref(surf_action_t action);
+XBT_PUBLIC(double) surf_action_get_start_time(surf_action_t action);
+XBT_PUBLIC(double) surf_action_get_finish_time(surf_action_t action);
+XBT_PUBLIC(double) surf_action_get_remains(surf_action_t action);
+XBT_PUBLIC(void) surf_action_suspend(surf_action_t action);
+XBT_PUBLIC(void) surf_action_resume(surf_action_t action);
+XBT_PUBLIC(void) surf_action_cancel(surf_action_t action);
+XBT_PUBLIC(void) surf_action_set_priority(surf_action_t action, double priority);
+XBT_PUBLIC(void) surf_action_set_category(surf_action_t action, const char *category);
+XBT_PUBLIC(e_surf_action_state_t) surf_action_get_state(surf_action_t action);
+XBT_PUBLIC(int) surf_action_get_cost(surf_action_t action);
+XBT_PUBLIC(void) surf_cpu_action_set_affinity(surf_action_t action, surf_resource_t cpu, unsigned long mask);
+XBT_PUBLIC(void) surf_cpu_action_set_bound(surf_action_t action, double bound);
+XBT_PUBLIC(surf_file_t) surf_storage_action_get_file(surf_action_t action);
+XBT_PUBLIC(xbt_dict_t) surf_storage_action_get_ls_dict(surf_action_t action);
+XBT_PUBLIC(surf_model_t) surf_resource_model(const void *host, int level);
/**************************************/
/* Implementations of model object */
/** \ingroup SURF_models
- * \brief The CPU model
+ * \brief The CPU model object for the physical machine layer
*/
-XBT_PUBLIC_DATA(surf_cpu_model_t) surf_cpu_model;
+XBT_PUBLIC_DATA(surf_cpu_model_t) surf_cpu_model_pm;
+
+/** \ingroup SURF_models
+ * \brief The CPU model object for the virtual machine layer
+ */
+XBT_PUBLIC_DATA(surf_cpu_model_t) surf_cpu_model_vm;
+
/** \ingroup SURF_models
* \brief Initializes the CPU model with the model Cas01
*/
XBT_PUBLIC_DATA(s_surf_model_description_t) surf_storage_model_description[];
+XBT_PUBLIC_DATA(surf_storage_model_t) surf_storage_model;
+
/** \ingroup SURF_models
* \brief The workstation model
*
*/
XBT_PUBLIC_DATA(surf_workstation_model_t) surf_workstation_model;
+/** \ingroup SURF_models
+ * \brief The vm_workstation model
+ *
+ * Note that when you create an API on top of SURF,
+ * the vm_workstation model should be the only one you use
+ * because depending on the platform model, the network model and the CPU model
+ * may not exist.
+ */
+XBT_PUBLIC_DATA(surf_vm_workstation_model_t) surf_vm_workstation_model;
+
/** \ingroup SURF_models
* \brief Initializes the platform with a compound workstation model
*
XBT_PUBLIC_DATA(s_surf_model_description_t)
surf_workstation_model_description[];
-/*******************************************
- * TUTORIAL: New model
+/** \ingroup SURF_models
+ * \brief Initializes the platform with the current best network and cpu models at hand
+ *
+ * This platform model seperates the workstation model and the network model.
+ * The workstation model will be initialized with the model compound, the network
+ * model with the model LV08 (with cross traffic support) and the CPU model with
+ * the model Cas01.
+ * Such model is subject to modification with warning in the ChangeLog so monitor it!
+ *
*/
-XBT_PUBLIC(void) surf_new_model_init_default(void);
+XBT_PUBLIC(void) surf_vm_workstation_model_init_current_default(void);
-XBT_PUBLIC_DATA(s_surf_model_description_t) surf_new_model_description[];
+/** \ingroup SURF_models
+ * \brief The list of all available vm workstation model models
+ */
+XBT_PUBLIC_DATA(s_surf_model_description_t)
+ surf_vm_workstation_model_description[];
/*******************************************/
* \brief List of initialized models
*/
XBT_PUBLIC_DATA(xbt_dynar_t) model_list;
+XBT_PUBLIC_DATA(xbt_dynar_t) model_list_invoke;
+
+/** \ingroup SURF_simulation
+ * \brief List of hosts that have juste restarted and whose autorestart process should be restarted.
+ */
+XBT_PUBLIC_DATA(xbt_dynar_t) host_that_restart;
+
+/** \ingroup SURF_simulation
+ * \brief List of hosts for which one want to be notified if they ever restart.
+ */
+XBT_PUBLIC(xbt_dict_t) watched_hosts_lib;
/*******************************************/
/*** SURF Platform *************************/
/*******************************************/
-#ifdef __cplusplus
-extern "C" {
-#endif
XBT_PUBLIC_DATA(AS_t) surf_AS_get_routing_root(void);
XBT_PUBLIC_DATA(const char *) surf_AS_get_name(AS_t as);
XBT_PUBLIC_DATA(xbt_dict_t) surf_AS_get_routing_sons(AS_t as);
XBT_PUBLIC_DATA(void) surf_AS_get_graph(AS_t as, xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges);
XBT_PUBLIC_DATA(AS_t) surf_platf_get_root(routing_platf_t platf);
XBT_PUBLIC_DATA(e_surf_network_element_type_t) surf_routing_edge_get_rc_type(sg_routing_edge_t edge);
-#ifdef __cplusplus
-}
-#endif
/*******************************************/
/*** SURF Globals **************************/
int surf_get_nthreads(void);
void surf_set_nthreads(int nthreads);
-void surf_watched_hosts(void);
-
/*
* Returns the initial path. On Windows the initial path is
* the current directory for the current process in the other
