static ssize_t show_power(struct device *dev,
struct device_attribute *devattr,
char *buf)
{
struct acpi_device *acpi_dev = to_acpi_device(dev);
struct acpi_power_meter_resource *resource = acpi_dev->driver_data;
mutex_lock(&resource->lock);
update_meter(resource);
mutex_unlock(&resource->lock);
return sprintf(buf, "%llu\n", resource->power * 1000);
}
/* Handle ACPI event notifications */
static void acpi_power_meter_notify(struct acpi_device *device, u32 event)
{
struct acpi_power_meter_resource *resource;
int res;
if (!device || !acpi_driver_data(device))
return;
resource = acpi_driver_data(device);
mutex_lock(&resource->lock);
switch (event) {
case METER_NOTIFY_CONFIG:
free_capabilities(resource);
res = read_capabilities(resource);
if (res)
break;
remove_attrs(resource);
setup_attrs(resource);
break;
case METER_NOTIFY_TRIP:
sysfs_notify(&device->dev.kobj, NULL, POWER_AVERAGE_NAME);
update_meter(resource);
break;
case METER_NOTIFY_CAP:
sysfs_notify(&device->dev.kobj, NULL, POWER_CAP_NAME);
update_cap(resource);
break;
case METER_NOTIFY_INTERVAL:
sysfs_notify(&device->dev.kobj, NULL, POWER_AVG_INTERVAL_NAME);
update_avg_interval(resource);
break;
case METER_NOTIFY_CAPPING:
sysfs_notify(&device->dev.kobj, NULL, POWER_ALARM_NAME);
dev_info(&device->dev, "Capping in progress.\n");
break;
default:
WARN(1, "Unexpected event %d\n", event);
break;
}
mutex_unlock(&resource->lock);
acpi_bus_generate_netlink_event(ACPI_POWER_METER_CLASS,
dev_name(&device->dev), event, 0);
}
/**
* Main function
*/
int main (int argc, char **argv)
{
char *test_name = "perf_stream_api";
char *cfg_file = "test_stream_local.conf";
uint64_t event_mask;
unsigned int count;
int ret;
meter = create_meter ((sizeof (data) / 4), "Generating random data\n", GNUNET_YES);
for (count=0; count < (sizeof (data) / 4); count++)
{
data[count] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
UINT32_MAX);
update_meter (meter);
}
reset_meter (meter);
free_meter (meter);
meter = NULL;
test_step = TEST_STEP_1_HOP;
for (payload_size_index = 0;
payload_size_index < (sizeof (payload_size) / sizeof (uint16_t));
payload_size_index++)
{
PRINTF ("\nTesting over loopback with payload size %hu\n",
payload_size[payload_size_index]);
(void) memset (peer_data, 0, sizeof (peer_data));
result = INIT;
reset_read = GNUNET_NO;
ret = GNUNET_TESTING_peer_run (test_name, cfg_file, &run, NULL);
if ((0 != ret) || (DOWNLINK_OK != result))
goto return_fail;
}
test_step = TEST_STEP_2_HOP;
num_peers = 2;
event_mask = 0;
event_mask |= (1LL << GNUNET_TESTBED_ET_CONNECT);
event_mask |= (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED);
for (payload_size_index = 0;
payload_size_index < (sizeof (payload_size) / sizeof (uint16_t));
payload_size_index++)
{
PRINTF ("\nTesting over 1 hop with payload size %hu\n",
payload_size[payload_size_index]);
(void) memset (peer_data, 0, sizeof (peer_data));
result = INIT;
reset_read = GNUNET_NO;
GNUNET_TESTBED_test_run (test_name, cfg_file, num_peers, event_mask,
&controller_event_cb, NULL, &test_master, NULL);
if (DOWNLINK_OK != result)
goto return_fail;
}
test_step = TEST_STEP_3_HOP;
for (payload_size_index = 0;
payload_size_index < (sizeof (payload_size) / sizeof (uint16_t));
payload_size_index++)
{
/* Initialize testbed here */
}
return 0;
return_fail:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Test failed\n");
return 1;
}
/**
* The write completion function; called upon writing some data to stream or
* upon error
*
* @param cls the closure from GNUNET_STREAM_write/read
* @param status the status of the stream at the time this function is called
* @param size the number of bytes written
*/
static void
write_completion (void *cls, enum GNUNET_STREAM_Status status, size_t size)
{
struct PeerData *pdata = cls;
double throughput;
double prof_time_sec;
unsigned int packets_wrote;
if (GNUNET_STREAM_OK != status)
{
GNUNET_SCHEDULER_cancel (abort_task);
abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
return;
}
GNUNET_assert (size <= DATA_SIZE);
packets_wrote = (size + payload_size[payload_size_index] - 1)
/ payload_size[payload_size_index];
pdata->bytes_wrote += size;
for (;packets_wrote > 0; packets_wrote--)
{
update_meter (meter);
pdata->packets_wrote++;
}
if (pdata->packets_wrote < MAX_PACKETS) /* Have more data to send */
{
size_t write_amount;
if (GNUNET_SCHEDULER_NO_TASK != abort_task)
{
GNUNET_SCHEDULER_cancel (abort_task);
abort_task =
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 300), &do_abort,
NULL);
}
write_amount = (MAX_PACKETS - pdata->packets_wrote) *
payload_size[payload_size_index];
if (write_amount > DATA_SIZE)
write_amount = DATA_SIZE;
reset_read = GNUNET_YES;
pdata->io_write_handle = GNUNET_STREAM_write (pdata->socket, data,
write_amount,
GNUNET_TIME_UNIT_FOREVER_REL,
&write_completion, pdata);
GNUNET_assert (NULL != pdata->io_write_handle);
}
else
{
free_meter (meter);
meter = NULL;
prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);
prof_time_sec = (((double) prof_time.rel_value)/ ((double) 1000));
throughput = ((float) pdata->bytes_wrote) / prof_time_sec;
PRINTF ("Throughput %.2f kB/sec\n", throughput / 1000.00);
switch (result)
{
case INIT:
result = UPLINK_OK;
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == read_task);
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == write_task);
pdata->bytes_read = 0;
pdata->packets_read = 0;
meter = create_meter (MAX_PACKETS, "Testing Downlink\n", GNUNET_YES);
read_task = GNUNET_SCHEDULER_add_now (&stream_read_task, &peer_data[0]);
write_task = GNUNET_SCHEDULER_add_now (&stream_write_task, &peer_data[1]);
break;
case UPLINK_OK:
result = DOWNLINK_OK;
GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
break;
case DOWNLINK_OK:
GNUNET_assert (0);
}
}
}
