* Model *
*********/
-void CpuModel::updateActionsStateLazy(double now, double delta)
+void CpuModel::updateActionsStateLazy(double now, double /*delta*/)
{
void *_action;
CpuActionLmmPtr action;
return (CpuCas01LmmPtr) xbt_lib_get_elm_or_null(host_lib, name);
}
-double CpuCas01Model::shareResourcesFull(double now)
+double CpuCas01Model::shareResourcesFull(double /*now*/)
{
return Model::shareResourcesMaxMin(p_runningActionSet,
p_maxminSystem, lmm_solve);
return (CpuTiPtr) xbt_lib_get_elm_or_null(host_lib, name);
}
-CpuTiActionPtr CpuTiModel::createAction(double cost, bool failed)
+CpuTiActionPtr CpuTiModel::createAction(double /*cost*/, bool /*failed*/)
{
return NULL;//new CpuTiAction(this, cost, failed);
}
return min_action_duration;
}
-void CpuTiModel::updateActionsState(double now, double delta)
+void CpuTiModel::updateActionsState(double now, double /*delta*/)
{
while ((xbt_heap_size(cpu_ti_action_heap) > 0)
&& (xbt_heap_maxkey(cpu_ti_action_heap) <= now)) {
void addTraces();
protected:
- void NotifyResourceTurnedOn(ResourcePtr r){};
- void NotifyResourceTurnedOff(ResourcePtr r){};
+ void NotifyResourceTurnedOn(ResourcePtr){};
+ void NotifyResourceTurnedOff(ResourcePtr){};
- void NotifyActionCancel(ActionPtr a){};
- void NotifyActionResume(ActionPtr a){};
- void NotifyActionSuspend(ActionPtr a){};
+ void NotifyActionCancel(ActionPtr){};
+ void NotifyActionResume(ActionPtr){};
+ void NotifyActionSuspend(ActionPtr){};
};
/************
double getAvailableSpeed();
xbt_dynar_t getWattsRangeList() {THROW_UNIMPLEMENTED;};
- double getCurrentWattsValue(double cpu_load) {THROW_UNIMPLEMENTED;};
- void updateEnergy(double cpu_load) {THROW_UNIMPLEMENTED;};
+ double getCurrentWattsValue(double /*cpu_load*/) {THROW_UNIMPLEMENTED;};
+ void updateEnergy(double /*cpu_load*/) {THROW_UNIMPLEMENTED;};
double getCurrentPowerPeak() {THROW_UNIMPLEMENTED;};
- double getPowerPeakAt(int pstate_index) {THROW_UNIMPLEMENTED;};
+ double getPowerPeakAt(int /*pstate_index*/) {THROW_UNIMPLEMENTED;};
int getNbPstates() {THROW_UNIMPLEMENTED;};
- void setPowerPeakAt(int pstate_index) {THROW_UNIMPLEMENTED;};
+ void setPowerPeakAt(int /*pstate_index*/) {THROW_UNIMPLEMENTED;};
double getConsumedEnergy() {THROW_UNIMPLEMENTED;};
CpuTiTgmrPtr p_availTrace; /*< Structure with data needed to integrate trace file */
return nw_link;
}
-void NetworkCm02Model::updateActionsStateLazy(double now, double delta)
+void NetworkCm02Model::updateActionsStateLazy(double now, double /*delta*/)
{
NetworkCm02ActionLmmPtr action;
while ((xbt_heap_size(p_actionHeap) > 0)
return action;
}
-double NetworkCm02Model::latencyFactor(double size) {
+double NetworkCm02Model::latencyFactor(double /*size*/) {
return sg_latency_factor;
}
-double NetworkCm02Model::bandwidthFactor(double size) {
+double NetworkCm02Model::bandwidthFactor(double /*size*/) {
return sg_bandwidth_factor;
}
-double NetworkCm02Model::bandwidthConstraint(double rate, double bound, double size) {
+double NetworkCm02Model::bandwidthConstraint(double rate, double /*bound*/, double /*size*/) {
return rate;
}
private:
void initialize();
public:
- NetworkCm02Model(int i) : Model("network") {
+ NetworkCm02Model(int /*i*/) : Model("network") {
f_networkSolve = lmm_solve;
m_haveGap = false;
};//FIXME: add network clean interface
e_surf_link_sharing_policy_t policy,
xbt_dict_t properties);
void updateActionsStateLazy(double now, double delta);
- virtual void gapAppend(double size, const NetworkCm02LinkLmmPtr link, NetworkCm02ActionLmmPtr action) {};
+ virtual void gapAppend(double /*size*/, const NetworkCm02LinkLmmPtr /*link*/, NetworkCm02ActionLmmPtr /*action*/) {};
virtual ActionPtr communicate(RoutingEdgePtr src, RoutingEdgePtr dst,
double size, double rate);
xbt_dynar_t getRoute(RoutingEdgePtr src, RoutingEdgePtr dst); //FIXME: kill field? That is done by the routing nowadays
XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_network);
static int host_number_int = 0;
-static void netcste_count_hosts(sg_platf_host_cbarg_t h) {
+static void netcste_count_hosts(sg_platf_host_cbarg_t /*h*/) {
host_number_int++;
}
routing_model_create(NULL);
}
-double NetworkConstantModel::shareResources(double now)
+double NetworkConstantModel::shareResources(double /*now*/)
{
void *_action = NULL;
NetworkConstantActionLmmPtr action = NULL;
return min;
}
-void NetworkConstantModel::updateActionsState(double now, double delta)
+void NetworkConstantModel::updateActionsState(double /*now*/, double delta)
{
void *_action, *_next_action;
NetworkConstantActionLmmPtr action = NULL;
return 0;
}
-void NetworkConstantLinkLmm::updateState(tmgr_trace_event_t event_type,
- double value, double time)
+void NetworkConstantLinkLmm::updateState(tmgr_trace_event_t /*event_type*/,
+ double /*value*/, double /*time*/)
{
DIE_IMPOSSIBLE;
}
}
#ifdef HAVE_TRACING
-void NetworkConstantActionLmm::setCategory(const char *category)
+void NetworkConstantActionLmm::setCategory(const char */*category*/)
{
//ignore completely the categories in constant model, they are not traced
}
storage->properties);
}
-static void parse_mstorage_init(sg_platf_mstorage_cbarg_t mstorage)
+static void parse_mstorage_init(sg_platf_mstorage_cbarg_t /*mstorage*/)
{
XBT_DEBUG("parse_mstorage_init");
}
-static void parse_storage_type_init(sg_platf_storage_type_cbarg_t storagetype_)
+static void parse_storage_type_init(sg_platf_storage_type_cbarg_t /*storagetype_*/)
{
XBT_DEBUG("parse_storage_type_init");
}
-static void parse_mount_init(sg_platf_mount_cbarg_t mount)
+static void parse_mount_init(sg_platf_mount_cbarg_t /*mount*/)
{
XBT_DEBUG("parse_mount_init");
}
ROUTING_STORAGE_TYPE_LEVEL,
(void *) stype);
}
-static void storage_parse_mstorage(sg_platf_mstorage_cbarg_t mstorage)
+static void storage_parse_mstorage(sg_platf_mstorage_cbarg_t /*mstorage*/)
{
THROW_UNIMPLEMENTED;
// mount_t mnt = xbt_new0(s_mount_t, 1);
return min_completion;
}
-void StorageModel::updateActionsState(double now, double delta)
+void StorageModel::updateActionsState(double /*now*/, double delta)
{
void *_action, *_next_action;
StorageActionLmmPtr action = NULL;
return false;
}
-void Storage::updateState(tmgr_trace_event_t event_type, double value, double date)
+void Storage::updateState(tmgr_trace_event_t /*event_type*/, double /*value*/, double /*date*/)
{
THROW_UNIMPLEMENTED;
}
return m_suspended == 1;
}
-void StorageActionLmm::setMaxDuration(double duration)
+void StorageActionLmm::setMaxDuration(double /*duration*/)
{
THROW_UNIMPLEMENTED;
}
-void StorageActionLmm::setPriority(double priority)
+void StorageActionLmm::setPriority(double /*priority*/)
{
THROW_UNIMPLEMENTED;
}
class StorageAction : virtual public Action {
public:
StorageAction(){};
- StorageAction(ModelPtr model, double cost, bool failed, StoragePtr storage, e_surf_action_storage_type_t type)
+ StorageAction(ModelPtr /*model*/, double /*cost*/, bool /*failed*/, StoragePtr storage, e_surf_action_storage_type_t type)
: p_storage(storage), m_type(type) {};
return min;
}
-double Model::shareResourcesFull(double now) {
+double Model::shareResourcesFull(double /*now*/) {
THROW_UNIMPLEMENTED;
}
xbt_die("Invalid cpu update mechanism!");
}
-void Model::updateActionsStateLazy(double now, double delta)
+void Model::updateActionsStateLazy(double /*now*/, double /*delta*/)
{
}
-void Model::updateActionsStateFull(double now, double delta)
+void Model::updateActionsStateFull(double /*now*/, double /*delta*/)
{
}
p_actionListHookup.prev = 0;
p_actionListHookup.next = 0;
};
- ActionLmm(ModelPtr model, double cost, bool failed) : m_suspended(false) {
+ ActionLmm(ModelPtr /*model*/, double /*cost*/, bool /*failed*/) : m_suspended(false) {
p_actionListHookup.prev = 0;
p_actionListHookup.next = 0;
};
* even if you add stuff to a closed AS
*
*/
-void routing_AS_end(sg_platf_AS_cbarg_t AS)
+void routing_AS_end(sg_platf_AS_cbarg_t /*AS*/)
{
if (current_routing == NULL) {
}
}
-void AsGeneric::parseRoute(sg_platf_route_cbarg_t route){
+void AsGeneric::parseRoute(sg_platf_route_cbarg_t /*route*/){
THROW_IMPOSSIBLE;
}
-void AsGeneric::parseASroute(sg_platf_route_cbarg_t route){
+void AsGeneric::parseASroute(sg_platf_route_cbarg_t /*route*/){
THROW_IMPOSSIBLE;
}
-void AsGeneric::getRouteAndLatency(RoutingEdgePtr src, RoutingEdgePtr dst, sg_platf_route_cbarg_t into, double *latency){
+void AsGeneric::getRouteAndLatency(RoutingEdgePtr /*src*/, RoutingEdgePtr /*dst*/, sg_platf_route_cbarg_t /*into*/, double */*latency*/){
THROW_IMPOSSIBLE;
}
-/* Copyright (c) 2009, 2010, 2011. The SimGrid Team.
+/* Copyright (c) 2009, 2010, 2011, 2013. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
return NULL;
}
-void AsNone::getRouteAndLatency(RoutingEdgePtr src, RoutingEdgePtr dst,
- sg_platf_route_cbarg_t res, double *lat)
+void AsNone::getRouteAndLatency(RoutingEdgePtr /*src*/, RoutingEdgePtr /*dst*/,
+ sg_platf_route_cbarg_t /*res*/, double *lat)
{
*lat = 0.0;
}
-void AsNone::getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges)
+void AsNone::getGraph(xbt_graph_t /*graph*/, xbt_dict_t /*nodes*/, xbt_dict_t /*edges*/)
{
XBT_INFO("No routing no graph");
}
-sg_platf_route_cbarg_t AsNone::getBypassRoute(RoutingEdgePtr src, RoutingEdgePtr dst, double *lat) {
+sg_platf_route_cbarg_t AsNone::getBypassRoute(RoutingEdgePtr /*src*/, RoutingEdgePtr /*dst*/, double */*lat*/) {
return NULL;
}
return -1;
}
-void AsNone::parseRoute(sg_platf_route_cbarg_t route){
+void AsNone::parseRoute(sg_platf_route_cbarg_t /*route*/){
THROW_IMPOSSIBLE;
}
-void AsNone::parseASroute(sg_platf_route_cbarg_t route){
+void AsNone::parseASroute(sg_platf_route_cbarg_t /*route*/){
THROW_IMPOSSIBLE;
}
-void AsNone::parseBypassroute(sg_platf_route_cbarg_t e_route){
+void AsNone::parseBypassroute(sg_platf_route_cbarg_t /*e_route*/){
THROW_IMPOSSIBLE;
}
return min_by_cpu; /* probably min_by_cpu == min_by_net == -1 */
}
-void WorkstationModel::updateActionsState(double now, double delta){
+void WorkstationModel::updateActionsState(double /*now*/, double /*delta*/){
return;
}
return -1;
}
-void WorkstationCLM03::updateState(tmgr_trace_event_t event_type, double value, double date){
+void WorkstationCLM03::updateState(tmgr_trace_event_t /*event_type*/, double /*value*/, double /*date*/){
THROW_IMPOSSIBLE; /* This model does not implement parallel tasks */
}
}
}
-double WorkstationL07Model::shareResources(double now)
+double WorkstationL07Model::shareResources(double /*now*/)
{
void *_action;
WorkstationL07ActionLmmPtr action;
return min;
}
-void WorkstationL07Model::updateActionsState(double now, double delta)
+void WorkstationL07Model::updateActionsState(double /*now*/, double delta)
{
double deltap = 0.0;
void *_action, *_next_action;
return static_cast<ActionPtr>(action);
}
-ResourcePtr WorkstationL07Model::createResource(const char *name, double power_scale,
- double power_initial,
- tmgr_trace_t power_trace,
- e_surf_resource_state_t state_initial,
- tmgr_trace_t state_trace,
- xbt_dict_t cpu_properties)
+ResourcePtr WorkstationL07Model::createResource(const char *name, double /*power_scale*/,
+ double /*power_initial*/,
+ tmgr_trace_t /*power_trace*/,
+ e_surf_resource_state_t /*state_initial*/,
+ tmgr_trace_t /*state_trace*/,
+ xbt_dict_t cpu_properties)
{
WorkstationL07Ptr wk = NULL;
xbt_assert(!surf_workstation_resource_priv(surf_workstation_resource_by_name(name)),
{
}
-double WorkstationL07::getPowerPeakAt(int pstate_index)
+double WorkstationL07::getPowerPeakAt(int /*pstate_index*/)
{
XBT_DEBUG("[ws_get_power_peak_at] Not implemented for workstation_ptask_L07");
return 0.0;
return 0.0;
}
-void WorkstationL07::setPowerPeakAt(int pstate_index)
+void WorkstationL07::setPowerPeakAt(int /*pstate_index*/)
{
XBT_DEBUG("[ws_set_power_peak_at] Not implemented for workstation_ptask_L07");
}
return lmm_constraint_used(ptask_maxmin_system, p_constraint);
}
-void CpuL07::updateState(tmgr_trace_event_t event_type, double value, double date){
+void CpuL07::updateState(tmgr_trace_event_t event_type, double value, double /*date*/){
XBT_DEBUG("Updating cpu %s (%p) with value %g", m_name, this, value);
if (event_type == p_power.event) {
m_powerCurrent = value;
e_surf_link_sharing_policy_t
policy, xbt_dict_t properties);
- xbt_dynar_t getRoute(WorkstationCLM03Ptr src, WorkstationCLM03Ptr dst) {DIE_IMPOSSIBLE;};
- ActionPtr communicate(RoutingEdgePtr src, RoutingEdgePtr dst, double size, double rate) {DIE_IMPOSSIBLE;};
+ xbt_dynar_t getRoute(WorkstationCLM03Ptr /*src*/, WorkstationCLM03Ptr /*dst*/) {DIE_IMPOSSIBLE;};
+ ActionPtr communicate(RoutingEdgePtr /*src*/, RoutingEdgePtr /*dst*/, double /*size*/, double /*rate*/) {DIE_IMPOSSIBLE;};
void addTraces() {DIE_IMPOSSIBLE;};
WorkstationL07ModelPtr p_workstationModel;
};
WorkstationL07(WorkstationModelPtr model, const char* name, xbt_dict_t props, RoutingEdgePtr netElm, CpuPtr cpu);
//bool isUsed();
bool isUsed() {DIE_IMPOSSIBLE;};
- void updateState(tmgr_trace_event_t event_type, double value, double date) {DIE_IMPOSSIBLE;};
+ void updateState(tmgr_trace_event_t /*event_type*/, double /*value*/, double /*date*/) {DIE_IMPOSSIBLE;};
ActionPtr execute(double size);
ActionPtr sleep(double duration);
e_surf_resource_state_t getState();
e_surf_resource_state_t getState();
double getSpeed(double load);
double getAvailableSpeed();
- ActionPtr execute(double size) {DIE_IMPOSSIBLE;};
- ActionPtr sleep(double duration) {DIE_IMPOSSIBLE;};
+ ActionPtr execute(double /*size*/) {DIE_IMPOSSIBLE;};
+ ActionPtr sleep(double /*duration*/) {DIE_IMPOSSIBLE;};
double getCurrentPowerPeak() {THROW_UNIMPLEMENTED;};
- double getPowerPeakAt(int pstate_index) {THROW_UNIMPLEMENTED;};
+ double getPowerPeakAt(int /*pstate_index*/) {THROW_UNIMPLEMENTED;};
int getNbPstates() {THROW_UNIMPLEMENTED;};
- void setPowerPeakAt(int pstate_index) {THROW_UNIMPLEMENTED;};
+ void setPowerPeakAt(int /*pstate_index*/) {THROW_UNIMPLEMENTED;};
double getConsumedEnergy() {THROW_UNIMPLEMENTED;};
double m_powerCurrent;
