This is ssdmodel_ssd_param.h
#ifndef _SSDMODEL_SSD_PARAM_H
#define _SSDMODEL_SSD_PARAM_H
#include "libparam.h"
#ifdef __cplusplus
extern"C"{
#endif
struct dm_disk_if;
/* prototype for ssdmodel_ssd param loader function */
struct ssd *ssdmodel_ssd_loadparams(struct lp_block *b, int *num);
typedef enum {
SSDMODEL_SSD_SCHEDULER,
SSDMODEL_SSD_MAX_QUEUE_LENGTH,
SSDMODEL_SSD_BLOCK_COUNT,
SSDMODEL_SSD_BUS_TRANSACTION_LATENCY,
SSDMODEL_SSD_BULK_SECTOR_TRANSFER_TIME,
SSDMODEL_SSD_NEVER_DISCONNECT,
SSDMODEL_SSD_PRINT_STATS,
SSDMODEL_SSD_COMMAND_OVERHEAD,
SSDMODEL_SSD_TIMING_MODEL,
SSDMODEL_SSD_FLASH_CHIP_ELEMENTS,
SSDMODEL_SSD_PAGE_SIZE,
SSDMODEL_SSD_PAGES_PER_BLOCK,
SSDMODEL_SSD_BLOCKS_PER_ELEMENT,
SSDMODEL_SSD_ELEMENT_STRIDE_PAGES,
SSDMODEL_SSD_CHIP_XFER_LATENCY,
SSDMODEL_SSD_PAGE_READ_LATENCY,
SSDMODEL_SSD_PAGE_WRITE_LATENCY,
SSDMODEL_SSD_BLOCK_ERASE_LATENCY,
SSDMODEL_SSD_WRITE_POLICY,
SSDMODEL_SSD_RESERVE_PAGES_PERCENTAGE,
SSDMODEL_SSD_MINIMUM_FREE_BLOCKS_PERCENTAGE,
SSDMODEL_SSD_CLEANING_POLICY,
SSDMODEL_SSD_PLANES_PER_PACKAGE,
SSDMODEL_SSD_BLOCKS_PER_PLANE,
SSDMODEL_SSD_PLANE_BLOCK_MAPPING,
SSDMODEL_SSD_COPY_BACK,
SSDMODEL_SSD_NUMBER_OF_PARALLEL_UNITS,
SSDMODEL_SSD_ELEMENTS_PER_GANG,
SSDMODEL_SSD_CLEANING_IN_BACKGROUND,
SSDMODEL_SSD_GANG_SHARE,
SSDMODEL_SSD_ALLOCATION_POOL_LOGIC
} ssdmodel_ssd_param_t;
#define SSDMODEL_SSD_MAX_PARAM SSDMODEL_SSD_ALLOCATION_POOL_LOGIC
extern void * SSDMODEL_SSD_loaders[];
extern lp_paramdep_t SSDMODEL_SSD_deps[];
static struct lp_varspec ssdmodel_ssd_params [] = {
{"Scheduler", BLOCK, 1 },
{"Max queue length", I, 1 },
{"Block count", I, 0 },
{"Bus transaction latency", D, 0 },
{"Bulk sector transfer time", D, 1 },
{"Never disconnect", I, 1 },
{"Print stats", I, 1 },
{"Command overhead", D, 1 },
{"Timing model", I, 1 },
{"Flash chip elements", I, 1 },
{"Page size", I, 1 },
{"Pages per block", I, 1 },
{"Blocks per element", I, 1 },
{"Element stride pages", I, 1 },
{"Chip xfer latency", D, 1 },
{"Page read latency", D, 1 },
{"Page write latency", D, 1 },
{"Block erase latency", D, 1 },
{"Write policy", I, 1 },
{"Reserve pages percentage", I, 1 },
{"Minimum free blocks percentage", I, 1 },
{"Cleaning policy", I, 1 },
{"Planes per package", I, 1 },
{"Blocks per plane", I, 1 },
{"Plane block mapping", I, 1 },
{"Copy back", I, 1 },
{"Number of parallel units", I, 1 },
{"Elements per gang", I, 1 },
{"Cleaning in background", I, 1 },
{"Gang share", I, 1 },
{"Allocation pool logic", I, 1 },
{0,0,0}
};
#define SSDMODEL_SSD_MAX 31
static struct lp_mod ssdmodel_ssd_mod = { "ssdmodel_ssd", ssdmodel_ssd_params, SSDMODEL_SSD_MAX, (lp_modloader_t)ssdmodel_ssd_loadparams, 0, 0, SSDMODEL_SSD_loaders, SSDMODEL_SSD_deps };
#ifdef __cplusplus
}
#endif
#endif // _SSDMODEL_SSD_PARAM_H
This is ssdmodel_ssd_param.c
#include "ssdmodel_ssd_param.h"
#include "bitvector.h"
#include "ssd.h"
static int SSDMODEL_SSD_SCHEDULER_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_SCHEDULER_loader(struct ssd * result, struct lp_block *blk) {
if (! (result->queue = (struct ioq *)disksim_ioqueue_loadparams(blk, device_printqueuestats, device_printcritstats, device_printidlestats, device_printintarrstats, device_printsizestats))) { // foo
}
}
static int SSDMODEL_SSD_MAX_QUEUE_LENGTH_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_MAX_QUEUE_LENGTH_loader(struct ssd * result, int i) {
if (! ((i >= 0))) { // foo
}
result->maxqlen = i;
}
static int SSDMODEL_SSD_BLOCK_COUNT_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_BLOCK_COUNT_loader(struct ssd * result, int i) {
if (! ((i > 0))) { // foo
}
result->numblocks = i;
}
static int SSDMODEL_SSD_BUS_TRANSACTION_LATENCY_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_BUS_TRANSACTION_LATENCY_loader(struct ssd * result, double d) {
if (! ((d >= 0.0))) { // foo
}
result->bus_transaction_latency = d;
}
static int SSDMODEL_SSD_BULK_SECTOR_TRANSFER_TIME_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_BULK_SECTOR_TRANSFER_TIME_loader(struct ssd * result, double d) {
if (! ((d >= 0.0))) { // foo
}
result->blktranstime = d;
}
static int SSDMODEL_SSD_NEVER_DISCONNECT_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_NEVER_DISCONNECT_loader(struct ssd * result, int i) {
if (! (RANGE(i,0,1))) { // foo
}
result->neverdisconnect = i;
}
static int SSDMODEL_SSD_PRINT_STATS_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_PRINT_STATS_loader(struct ssd * result, int i) {
if (! (RANGE(i,0,1))) { // foo
}
result->printstats = i;
}
static int SSDMODEL_SSD_COMMAND_OVERHEAD_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_COMMAND_OVERHEAD_loader(struct ssd * result, double d) {
if (! ((d >= 0.0))) { // foo
}
result->overhead = d;
}
static int SSDMODEL_SSD_TIMING_MODEL_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_TIMING_MODEL_loader(struct ssd * result, int i) {
if (! (RANGE(i,SSD_SIMPLE_MODEL,SSD_LOGDISK_MODEL))) { // foo
}
result->params.ssd_model = i;
}
static int SSDMODEL_SSD_FLASH_CHIP_ELEMENTS_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_FLASH_CHIP_ELEMENTS_loader(struct ssd * result, int i) {
if (! ((i >= 0))) { // foo
}
result->params.nelements = i;
}
static int SSDMODEL_SSD_PAGE_SIZE_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_PAGE_SIZE_loader(struct ssd * result, int i) {
if (! ((i >= 0))) { // foo
}
result->params.page_size = i;
}
static int SSDMODEL_SSD_PAGES_PER_BLOCK_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_PAGES_PER_BLOCK_loader(struct ssd * result, int i) {
if (! ((i >= 0))) { // foo
}
result->params.pages_per_block = i;
}
static int SSDMODEL_SSD_BLOCKS_PER_ELEMENT_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_BLOCKS_PER_ELEMENT_loader(struct ssd * result, int i) {
if (! ((i >= 0))) { // foo
}
result->params.blocks_per_element = i;
}
static int SSDMODEL_SSD_ELEMENT_STRIDE_PAGES_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_ELEMENT_STRIDE_PAGES_loader(struct ssd * result, int i) {
if (! ((i >= 0))) { // foo
}
result->params.element_stride_pages = i;
}
static int SSDMODEL_SSD_CHIP_XFER_LATENCY_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_CHIP_XFER_LATENCY_loader(struct ssd * result, double d) {
if (! ((d >= 0))) { // foo
}
result->params.chip_xfer_latency = d;
}
static int SSDMODEL_SSD_PAGE_READ_LATENCY_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_PAGE_READ_LATENCY_loader(struct ssd * result, double d) {
if (! ((d >= 0))) { // foo
}
result->params.page_read_latency = d;
}
static int SSDMODEL_SSD_PAGE_WRITE_LATENCY_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_PAGE_WRITE_LATENCY_loader(struct ssd * result, double d) {
if (! ((d >= 0))) { // foo
}
result->params.page_write_latency = d;
}
static int SSDMODEL_SSD_BLOCK_ERASE_LATENCY_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_BLOCK_ERASE_LATENCY_loader(struct ssd * result, double d) {
if (! ((d >= 0))) { // foo
}
result->params.block_erase_latency = d;
}
static int SSDMODEL_SSD_WRITE_POLICY_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_WRITE_POLICY_loader(struct ssd * result, int i) {
if (! ((i >= 0))) { // foo
}
result->params.write_policy = i;
}
static int SSDMODEL_SSD_RESERVE_PAGES_PERCENTAGE_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_RESERVE_PAGES_PERCENTAGE_loader(struct ssd * result, int i) {
if (! ((i >= 0))) { // foo
}
result->params.reserve_blocks = i;
}
static int SSDMODEL_SSD_MINIMUM_FREE_BLOCKS_PERCENTAGE_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_MINIMUM_FREE_BLOCKS_PERCENTAGE_loader(struct ssd * result, int i) {
if (! ((i >= 0))) { // foo
}
result->params.min_freeblks_percent = i;
}
static int SSDMODEL_SSD_CLEANING_POLICY_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_CLEANING_POLICY_loader(struct ssd * result, int i) {
if (! ((i >= 0))) { // foo
}
result->params.cleaning_policy = i;
}
static int SSDMODEL_SSD_PLANES_PER_PACKAGE_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_PLANES_PER_PACKAGE_loader(struct ssd * result, int i) {
if (! ((i >= 0))) { // foo
}
result->params.planes_per_pkg = i;
}
static int SSDMODEL_SSD_BLOCKS_PER_PLANE_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_BLOCKS_PER_PLANE_loader(struct ssd * result, int i) {
if (! ((i >= 0))) { // foo
}
result->params.blocks_per_plane = i;
}
static int SSDMODEL_SSD_PLANE_BLOCK_MAPPING_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_PLANE_BLOCK_MAPPING_loader(struct ssd * result, int i) {
if (! ((i >= 0))) { // foo
}
result->params.plane_block_mapping = i;
}
static int SSDMODEL_SSD_COPY_BACK_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_COPY_BACK_loader(struct ssd * result, int i) {
if (! (RANGE(i,0,1))) { // foo
}
result->params.copy_back = i;
}
static int SSDMODEL_SSD_NUMBER_OF_PARALLEL_UNITS_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_NUMBER_OF_PARALLEL_UNITS_loader(struct ssd * result, int i) {
if (! ((i >= 0.0))) { // foo
}
result->params.num_parunits = i;
}
static int SSDMODEL_SSD_ELEMENTS_PER_GANG_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_ELEMENTS_PER_GANG_loader(struct ssd * result, int i) {
if (! ((i >= 0))) { // foo
}
result->params.elements_per_gang = i;
}
static int SSDMODEL_SSD_CLEANING_IN_BACKGROUND_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_CLEANING_IN_BACKGROUND_loader(struct ssd * result, int i) {
if (! (RANGE(i,0,1))) { // foo
}
result->params.cleaning_in_background = i;
}
static int SSDMODEL_SSD_GANG_SHARE_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_GANG_SHARE_loader(struct ssd * result, int i) {
if (! ((i >= 0))) { // foo
}
result->params.gang_share = i;
}
static int SSDMODEL_SSD_ALLOCATION_POOL_LOGIC_depend(char *bv) {
return -1;
}
static void SSDMODEL_SSD_ALLOCATION_POOL_LOGIC_loader(struct ssd * result, int i) {
if (! ((i >= 0))) { // foo
}
result->params.alloc_pool_logic = i;
}
void * SSDMODEL_SSD_loaders[] = {
(void *)SSDMODEL_SSD_SCHEDULER_loader,
(void *)SSDMODEL_SSD_MAX_QUEUE_LENGTH_loader,
(void *)SSDMODEL_SSD_BLOCK_COUNT_loader,
(void *)SSDMODEL_SSD_BUS_TRANSACTION_LATENCY_loader,
(void *)SSDMODEL_SSD_BULK_SECTOR_TRANSFER_TIME_loader,
(void *)SSDMODEL_SSD_NEVER_DISCONNECT_loader,
(void *)SSDMODEL_SSD_PRINT_STATS_loader,
(void *)SSDMODEL_SSD_COMMAND_OVERHEAD_loader,
(void *)SSDMODEL_SSD_TIMING_MODEL_loader,
(void *)SSDMODEL_SSD_FLASH_CHIP_ELEMENTS_loader,
(void *)SSDMODEL_SSD_PAGE_SIZE_loader,
(void *)SSDMODEL_SSD_PAGES_PER_BLOCK_loader,
(void *)SSDMODEL_SSD_BLOCKS_PER_ELEMENT_loader,
(void *)SSDMODEL_SSD_ELEMENT_STRIDE_PAGES_loader,
(void *)SSDMODEL_SSD_CHIP_XFER_LATENCY_loader,
(void *)SSDMODEL_SSD_PAGE_READ_LATENCY_loader,
(void *)SSDMODEL_SSD_PAGE_WRITE_LATENCY_loader,
(void *)SSDMODEL_SSD_BLOCK_ERASE_LATENCY_loader,
(void *)SSDMODEL_SSD_WRITE_POLICY_loader,
(void *)SSDMODEL_SSD_RESERVE_PAGES_PERCENTAGE_loader,
(void *)SSDMODEL_SSD_MINIMUM_FREE_BLOCKS_PERCENTAGE_loader,
(void *)SSDMODEL_SSD_CLEANING_POLICY_loader,
(void *)SSDMODEL_SSD_PLANES_PER_PACKAGE_loader,
(void *)SSDMODEL_SSD_BLOCKS_PER_PLANE_loader,
(void *)SSDMODEL_SSD_PLANE_BLOCK_MAPPING_loader,
(void *)SSDMODEL_SSD_COPY_BACK_loader,
(void *)SSDMODEL_SSD_NUMBER_OF_PARALLEL_UNITS_loader,
(void *)SSDMODEL_SSD_ELEMENTS_PER_GANG_loader,
(void *)SSDMODEL_SSD_CLEANING_IN_BACKGROUND_loader,
(void *)SSDMODEL_SSD_GANG_SHARE_loader,
(void *)SSDMODEL_SSD_ALLOCATION_POOL_LOGIC_loader
};
lp_paramdep_t SSDMODEL_SSD_deps[] = {
SSDMODEL_SSD_SCHEDULER_depend,
SSDMODEL_SSD_MAX_QUEUE_LENGTH_depend,
SSDMODEL_SSD_BLOCK_COUNT_depend,
SSDMODEL_SSD_BUS_TRANSACTION_LATENCY_depend,
SSDMODEL_SSD_BULK_SECTOR_TRANSFER_TIME_depend,
SSDMODEL_SSD_NEVER_DISCONNECT_depend,
SSDMODEL_SSD_PRINT_STATS_depend,
SSDMODEL_SSD_COMMAND_OVERHEAD_depend,
SSDMODEL_SSD_TIMING_MODEL_depend,
SSDMODEL_SSD_FLASH_CHIP_ELEMENTS_depend,
SSDMODEL_SSD_PAGE_SIZE_depend,
SSDMODEL_SSD_PAGES_PER_BLOCK_depend,
SSDMODEL_SSD_BLOCKS_PER_ELEMENT_depend,
SSDMODEL_SSD_ELEMENT_STRIDE_PAGES_depend,
SSDMODEL_SSD_CHIP_XFER_LATENCY_depend,
SSDMODEL_SSD_PAGE_READ_LATENCY_depend,
SSDMODEL_SSD_PAGE_WRITE_LATENCY_depend,
SSDMODEL_SSD_BLOCK_ERASE_LATENCY_depend,
SSDMODEL_SSD_WRITE_POLICY_depend,
SSDMODEL_SSD_RESERVE_PAGES_PERCENTAGE_depend,
SSDMODEL_SSD_MINIMUM_FREE_BLOCKS_PERCENTAGE_depend,
SSDMODEL_SSD_CLEANING_POLICY_depend,
SSDMODEL_SSD_PLANES_PER_PACKAGE_depend,
SSDMODEL_SSD_BLOCKS_PER_PLANE_depend,
SSDMODEL_SSD_PLANE_BLOCK_MAPPING_depend,
SSDMODEL_SSD_COPY_BACK_depend,
SSDMODEL_SSD_NUMBER_OF_PARALLEL_UNITS_depend,
SSDMODEL_SSD_ELEMENTS_PER_GANG_depend,
SSDMODEL_SSD_CLEANING_IN_BACKGROUND_depend,
SSDMODEL_SSD_GANG_SHARE_depend,
SSDMODEL_SSD_ALLOCATION_POOL_LOGIC_depend
};
The above two files are two source programs of disksim4.0.I put the above two files into ns-3.26/src/mymodule/model path, and configured the source code name and header file name in wscript file. When compiling, there was a link error. What should I do to solve it?
[ 539/2093] Compiling src/mymodule/model/ssd.c
[ 540/2093] Compiling src/mymodule/model/ssdmodel_ssd_param.c
[ 559/2093] Compiling src/mymodule/model/ssd_clean.c
[ 560/2093] Compiling src/mymodule/model/ssd_gang.c
[ 561/2093] Compiling src/mymodule/model/ssd_timing.c
[ 564/2093] Compiling src/mymodule/model/ssd_init.c
[ 581/2093] Compiling install-ns3-header: ns3/ssdmodel_ssd_param.h
[1995/2093] Linking build/libns3.26-mymodule-debug.so
src/mymodule/model/ssdmodel_ssd_param.c.1.o:(.data+0x1c0): multiple definition of `SSDMODEL_SSD_loaders'
src/mymodule/model/ssdmodel_ssd_param.c.1.o:(.data+0x1c0): first defined here
src/mymodule/model/ssdmodel_ssd_param.c.1.o:(.data+0x240): multiple definition of `SSDMODEL_SSD_deps'
src/mymodule/model/ssdmodel_ssd_param.c.1.o:(.data+0x240): first defined here
collect2: error: ld returned 1 exit status