I think the size of the executable depends on how you used the logging component in your TOS applications. The reasons are nesC compiler does aggressive inlining and by default, TinyOS build system optimizes for code size (-Os is passed to C compiler).
You can try turning off inlining and optimization for code size. Also, make sure the component is used in the same way in both TOS applications. To turn off inlining, pass -fnesc-no-inline to nesc compiler and -O0 to C compiler. I guess both can be done by adding them to PFLAGS in your make file like below. PFLAGS += -fnesc-no-inline -O0 It will be interesting if the memory sizes still vary. Hope this helps, Vinai -- Vinai Sundaram Graduate Research Assistant School of Electrical and Computer Engineering Purdue University West Lafayette IN USA Web: http://www.ece.purdue.edu/~vsundar/ 2011/3/24 Anna Förster <[email protected]>: > Dear all, > > we have been facing a weird problem with memory consumption after > compilation. The basic trouble is that including the same piece of software > into different TOS applications results in different increases of memory > consumption (as shown after compilation). We would like to understand where > these differences come from and why and would be very grateful for some > explanation/ideas/discussion. Details about our code follow below. > > The code in question is a combination of TOS components and nesc code, which > enables logging some data on the flash in a simple format and printing it out > to the serila interface. When including it into two different applications, > we get different increases in the memory consumption: in one case +7816/+362 > (ROM/RAM) and in the other case it is only +6218/+322 (ROM/RAM). > > The implementation is realized as to be dependant on a #define statement of > LOG_ENABLED. Again, the included code and header files are EXACTLY the same > for both applications. My first guess would be that there is some kind of an > optimization among TOS components. However, the used TOS components in both > applications are IDENTICAL too. The difference is in the implementation > itself in the BlaC.nc files only. > > Let me know if you need also teh full code for both applications. We are very > thankful for any ideas or explanations! > > The implementation is the following: > > ************************* > in BlaAppC.nc: > ************************* > implementation { > > ... > > #ifdef LOG_ENABLED > components SerialActiveMessageC; > components new SerialAMSenderC(AM_FLEXOR_LOG); > App.SerialAMControl -> SerialActiveMessageC; > App.SerialDataLogPacket -> SerialAMSenderC.Packet; > App.SerialDataLogAMPacket-> SerialAMSenderC.AMPacket; > App.SerialDataLogAMSend -> SerialAMSenderC.AMSend; > components new LogStorageC(VOLUME_LOGTEST, FALSE) as DataLogStorageC; > App.DataLogRead -> DataLogStorageC.LogRead; > App.DataLogWrite -> DataLogStorageC.LogWrite; > #endif > > ... > } > > ************************* > in BlaC.nc: > ************************* > #include "log.h" > > ************************* > in log.h: > ************************* > #ifndef FLEXOR_LOG > #define FLEXOR_LOG > > //Log struct for reading > typedef struct flexor_log_struct { > uint32_t dataToLog; > uint32_t timeStamp; > uint16_t dataType; > } flexor_log_struct_t; > > > flexor_log_struct_t readlog_data; > > #ifdef LOG_ENABLED > > #define LOG_WRITE_BUFFER_SIZE 10 > > bool log_busy=FALSE; > bool append_busy=FALSE; > bool read_scheduled=FALSE; > bool erase_scheduled=FALSE; > bool serial_busy; > > message_t log_tos_data; > > // Log buffer for to store the incoming log if log write is busy > flexor_log_struct_t log_buffer[LOG_WRITE_BUFFER_SIZE]; > > //index for tracking the buffer for writing the log > uint8_t buffer_index; > > // tasks for the log read, erase and transmission of the data log read > task void transmitLogData(); > task void readLogData(); > task void eraseLogData(); > > void flexor_log_init() > { > > log_busy=FALSE; > append_busy=FALSE; > read_scheduled=FALSE; > erase_scheduled=FALSE; > buffer_index=0; > } > > task void readLogData() > { > bool status; > if(!log_busy) > { > status = call > DataLogRead.read(&readlog_data,sizeof(flexor_log_struct_t)); > if(status == SUCCESS) > { > log_busy=TRUE; > atomic printf("Read Log \n"); > } > else > { > // if log is being written then again post > reading the log as a task so that it will execute for sure > post readLogData(); > } > } > else > { > read_scheduled=TRUE; > printf("Read Scheduled\n"); > } > atomic printfflush(); > } > task void eraseLogData() > { > if(!log_busy) > { > > if(call DataLogWrite.erase()==SUCCESS) > { > log_busy=TRUE; > printf("Erasing Log\n"); > } > else > { > printf("Error Erasing the Data Log\n"); > post eraseLogData(); > } > } > else > { > erase_scheduled=TRUE; > printf("Erase Scheduled\n"); > } > atomic printfflush(); > } > > /* DATA LOG TRANSMISSION*/ > > task void transmitLogData() > { > > flexor_log_struct_t* log_data = (flexor_log_struct_t*)(call > SerialDataLogPacket.getPayload(&log_tos_data, (sizeof(flexor_log_struct_t)))); > bool status; > > /***copying the read log data into the log_data t transmit to > the serial port****/ > memcpy(log_data, &readlog_data,(sizeof(flexor_log_struct_t))); > > // sending the log data to the serial port > status = call > SerialDataLogAMSend.send(AM_BROADCAST_ADDR,&log_tos_data, > sizeof(flexor_log_struct_t)); > if(status == SUCCESS) > { > serial_busy = TRUE; > //printf("log transmit \n"); > } > else if(status == EBUSY) > { > //printf("Network is Busy"); > post transmitLogData(); > } > > //printfflush(); > > } > #endif > > /** END OF DATA LOG TRANSMISSION**/ > void flexor_write_log(flexor_log_struct_t* writelog_data) > { > #ifdef LOG_ENABLED > bool status; > if(!append_busy) > { > if(buffer_index<LOG_WRITE_BUFFER_SIZE) > { > atomic printf("buf writing\n"); > > memcpy(&log_buffer[buffer_index],writelog_data,sizeof(flexor_log_struct_t)); > buffer_index++; > } > } > else > { > // do noting and drop the packet > } > > if((buffer_index==LOG_WRITE_BUFFER_SIZE)&&(!log_busy)) > { > /***** writing the data to the log storge of mote*****/ > atomic printf("buf full\n"); > status = call > DataLogWrite.append(&log_buffer,(LOG_WRITE_BUFFER_SIZE*sizeof(flexor_log_struct_t))); > if(status == SUCCESS) > { > append_busy=TRUE; > log_busy=TRUE; > buffer_index=0; > } > > } > atomic printfflush(); > #endif > } > > void flexor_read_log() > { > #ifdef LOG_ENABLED > post readLogData(); > #endif > } > > void flexor_erase_log() > { > #ifdef LOG_ENABLED > post eraseLogData(); > #endif > } > > > /******************************************************************************** > EVENTS GENERATED BY LOG READ WRITE AND ERASE FUNCTIONS > > *******************************************************************************/ > #ifdef LOG_ENABLED > event void DataLogWrite.appendDone(void* buf, storage_len_t len,bool > recordsLost, error_t err) > { > if(err == SUCCESS) > { > append_busy=FALSE; > log_busy=TRUE; > call DataLogWrite.sync(); > atomic printf("Data Written Success\n"); > } > else > { > printf("Error Appending the Log\n"); > append_busy=FALSE; > log_busy=FALSE; > > } > atomic printfflush(); > } > > event void DataLogRead.readDone(void* buf,storage_len_t len,error_t > err) > { > if((len == sizeof(flexor_log_struct_t)) && (buf == > &readlog_data)) > { > /*sending the log data*/ > atomic printf("Transmit data\n"); > log_busy=TRUE; > post transmitLogData(); > } > else > { > log_busy=FALSE; > read_scheduled=FALSE; > if(len==0) > { > atomic printf("End of Reading the Log\n"); > if(erase_scheduled) > { > post eraseLogData(); > } > } > > } > atomic printfflush(); > } > event void DataLogWrite.eraseDone(error_t err) { > if (err == SUCCESS) > { > log_busy=FALSE; > erase_scheduled=FALSE; > atomic printf("Log Erased\n"); > if(read_scheduled) > post readLogData(); > } > > atomic printfflush(); > } > > > event void DataLogRead.seekDone(error_t err) { > } > > event void DataLogWrite.syncDone(error_t err) { > log_busy=FALSE; > append_busy=FALSE; > atomic printf("sync done"); > if(read_scheduled) > post readLogData(); > else if (erase_scheduled) > post eraseLogData(); > atomic printfflush(); > } > > > /******************************************************************************** > END OF EVENTS GENERATED BY LOG READ WRITE AND ERASE FUNCTIONS > > *******************************************************************************/ > /*#else > > void flexor_read_log() > {} > > void flexor_erase_log() > {} > > void flexor_write_log(flexor_log_struct_t* writelog_data) > {} > > #endif*/ > > > /**************** SERIAL AM CONTROL START AND STOP DONE***************/ > > event void SerialAMControl.startDone(error_t error) > { > > } > > event void SerialAMControl.stopDone(error_t error) > { > > } > > /***** SERIAL DATA SEND DONE ******/ > > //#ifdef LOG_ENABLED > event void SerialDataLogAMSend.sendDone(message_t* msg, error_t error) > { > if(&log_tos_data == msg) > { > serial_busy = FALSE; > //printf("Log Data Message Sent Successfully \n"); > call SerialDataLogPacket.clear(msg); > if(call > DataLogRead.read(&readlog_data,sizeof(flexor_log_struct_t)) != SUCCESS ) > { > //printf("Error Reading the Log\n"); > } > else > { > read_scheduled=FALSE; > log_busy=FALSE; > } > } > //printfflush(); > } > //#endif > > > > /******************************************************************************** > END OF LOG READ WRITE AND ERASE FUNCTIONS > > > *******************************************************************************/ > #endif > #endif > > > -- > Dr. Anna Förster > PostDoctoral Researcher > Networking Laboratory, SUPSI > Via Cantonale, Galleria 2 > Manno, Switzerland > Tel. + 41 58 666 6597 > http://www.dti.supsi.ch/~afoerste/ > > > _______________________________________________ > Tinyos-help mailing list > [email protected] > https://www.millennium.berkeley.edu/cgi-bin/mailman/listinfo/tinyos-help > _______________________________________________ Tinyos-help mailing list [email protected] https://www.millennium.berkeley.edu/cgi-bin/mailman/listinfo/tinyos-help
