1 /* Copyright (c) 2006-2016. The SimGrid Team.
2 * All rights reserved. */
4 /* This program is free software; you can redistribute it and/or modify it
5 * under the terms of the license (GNU LGPL) which comes with this package. */
7 #include "src/surf/host_interface.hpp"
8 #include "src/simdag/simdag_private.h"
9 #include "simgrid/simdag.h"
10 #include "simgrid/host.h"
11 #include <simgrid/s4u/host.hpp>
14 #include "xbt/sysdep.h"
15 #include "surf/surf.h"
17 /* Creates a storage and registers it in SD.
19 SD_storage_t __SD_storage_create(void *surf_storage, void *data)
22 SD_storage_priv_t storage;
25 storage = xbt_new(s_SD_storage_priv_t, 1);
26 storage->data = data; /* user data */
27 name = surf_resource_name((surf_cpp_resource_t)surf_storage);
28 storage->host = (const char*)surf_storage_get_host( (surf_resource_t )surf_storage_resource_by_name(name));
29 xbt_lib_set(storage_lib,name, SD_STORAGE_LEVEL, storage);
30 return xbt_lib_get_elm_or_null(storage_lib, name);
33 /* Destroys a storage.
35 void __SD_storage_destroy(void *storage)
39 s = (SD_storage_priv_t) storage;
43 double sg_host_computation_time(sg_host_t host, double flops_amount)
45 xbt_assert(flops_amount >= 0,
46 "flops_amount must be greater than or equal to zero");
47 return flops_amount / sg_host_speed(host);
51 * \brief Returns the route between two workstations
53 * Use SD_route_get_size() to know the array size.
55 * \param src a workstation
56 * \param dst another workstation
57 * \return a new array of \ref SD_link_t representing the route between these two workstations
58 * \see SD_route_get_size(), SD_link_t
60 const SD_link_t *SD_route_get_list(sg_host_t src,
63 xbt_dynar_t surf_route;
67 if (sd_global->recyclable_route == NULL) {
69 sd_global->recyclable_route = xbt_new(SD_link_t, sg_link_count());
72 surf_route = surf_host_model_get_route((surf_host_model_t)surf_host_model, src, dst);
74 xbt_dynar_foreach(surf_route, cpt, surf_link) {
75 sd_global->recyclable_route[cpt] = (SD_link_t)surf_link;
77 return sd_global->recyclable_route;
81 * \brief Returns the number of links on the route between two workstations
83 * \param src a workstation
84 * \param dst another workstation
85 * \return the number of links on the route between these two workstations
86 * \see SD_route_get_list()
88 int SD_route_get_size(sg_host_t src, sg_host_t dst)
90 return xbt_dynar_length(surf_host_model_get_route(
91 (surf_host_model_t)surf_host_model, src, dst));
95 * \brief Returns an approximative estimated time for the given computation amount on a workstation
97 * \param workstation a workstation
98 * \param flops_amount the computation amount you want to evaluate (in flops)
99 * \return an approximative estimated computation time for the given computation amount on this workstation (in seconds)
102 * \brief Returns the latency of the route between two workstations.
104 * \param src the first workstation
105 * \param dst the second workstation
106 * \return the latency of the route between the two workstations (in seconds)
107 * \see SD_route_get_bandwidth()
109 double SD_route_get_latency(sg_host_t src, sg_host_t dst)
111 xbt_dynar_t route = NULL;
114 routing_platf->getRouteAndLatency(src->pimpl_netcard, dst->pimpl_netcard,
121 * \brief Returns the bandwidth of the route between two workstations,
122 * i.e. the minimum link bandwidth of all between the workstations.
124 * \param src the first workstation
125 * \param dst the second workstation
126 * \return the bandwidth of the route between the two workstations
128 * \see SD_route_get_latency()
130 double SD_route_get_bandwidth(sg_host_t src, sg_host_t dst)
133 const SD_link_t *links;
136 double min_bandwidth;
139 links = SD_route_get_list(src, dst);
140 nb_links = SD_route_get_size(src, dst);
141 min_bandwidth = -1.0;
143 for (i = 0; i < nb_links; i++) {
144 bandwidth = sg_link_bandwidth(links[i]);
145 if (bandwidth < min_bandwidth || min_bandwidth == -1.0)
146 min_bandwidth = bandwidth;
149 return min_bandwidth;
153 * \brief Returns an approximative estimated time for the given
154 * communication amount between two workstations
156 * \param src the first workstation
157 * \param dst the second workstation
158 * \param bytes_amount the communication amount you want to evaluate (in bytes)
159 * \return an approximative estimated communication time for the given bytes amount
160 * between the workstations (in seconds)
162 double SD_route_get_communication_time(sg_host_t src,
168 /* total time = latency + transmission time of the slowest link
169 transmission time of a link = communication amount / link bandwidth */
171 const SD_link_t *links;
172 xbt_dynar_t route = NULL;
174 double bandwidth, min_bandwidth;
178 xbt_assert(bytes_amount >= 0, "bytes_amount must be greater than or equal to zero");
181 if (bytes_amount == 0.0)
184 routing_platf->getRouteAndLatency(src->pimpl_netcard, dst->pimpl_netcard,
187 links = SD_route_get_list(src, dst);
188 nb_links = SD_route_get_size(src, dst);
189 min_bandwidth = -1.0;
191 for (i = 0; i < nb_links; i++) {
192 bandwidth = sg_link_bandwidth(links[i]);
193 if (bandwidth < min_bandwidth || min_bandwidth == -1.0)
194 min_bandwidth = bandwidth;
197 return latency + (bytes_amount / min_bandwidth);
201 * \brief Return the list of mounted storages on a workstation.
203 * \param workstation a workstation
204 * \return a dynar containing all mounted storages on the workstation
207 * \brief Return the list of mounted storages on a workstation.
209 * \param workstation a workstation
210 * \return a dynar containing all mounted storages on the workstation
213 * \brief Returns the host name the storage is attached to
215 * This functions checks whether a storage is a valid pointer or not and return its name.
217 const char *SD_storage_get_host(msg_storage_t storage) {
218 xbt_assert((storage != NULL), "Invalid parameters");
219 SD_storage_priv_t priv = SD_storage_priv(storage);