static void sun3fb_clear_margin(struct display *p, int s)
{
struct fb_info_sbusfb *fb = sbusfbinfod(p);
return;
if (fb->switch_from_graph)
(*fb->switch_from_graph)(fb);
if (fb->fill) {
unsigned short rects [16];
rects [0] = 0;
rects [1] = 0;
rects [2] = fb->var.xres_virtual;
rects [3] = fb->y_margin;
rects [4] = 0;
rects [5] = fb->y_margin;
rects [6] = fb->x_margin;
rects [7] = fb->var.yres_virtual;
rects [8] = fb->var.xres_virtual - fb->x_margin;
rects [9] = fb->y_margin;
rects [10] = fb->var.xres_virtual;
rects [11] = fb->var.yres_virtual;
rects [12] = fb->x_margin;
rects [13] = fb->var.yres_virtual - fb->y_margin;
rects [14] = fb->var.xres_virtual - fb->x_margin;
rects [15] = fb->var.yres_virtual;
(*fb->fill)(fb, p, s, 4, rects);
} else {
unsigned char *fb_base = fb->info.screen_base, *q;
int skip_bytes = fb->y_margin * fb->var.xres_virtual;
int scr_size = fb->var.xres_virtual * fb->var.yres_virtual;
int h, he, incr, size;
he = fb->var.yres;
if (fb->var.bits_per_pixel == 1) {
fb_base -= (skip_bytes + fb->x_margin) / 8;
skip_bytes /= 8;
scr_size /= 8;
mymemset (fb_base, skip_bytes - fb->x_margin / 8);
mymemset (fb_base + scr_size - skip_bytes + fb->x_margin / 8, skip_bytes - fb->x_margin / 8);
incr = fb->var.xres_virtual / 8;
size = fb->x_margin / 8 * 2;
for (q = fb_base + skip_bytes - fb->x_margin / 8, h = 0;
h <= he; q += incr, h++)
mymemset (q, size);
} else {
fb_base -= (skip_bytes + fb->x_margin);
memset (fb_base, attr_bgcol(p,s), skip_bytes - fb->x_margin);
memset (fb_base + scr_size - skip_bytes + fb->x_margin, attr_bgcol(p,s), skip_bytes - fb->x_margin);
incr = fb->var.xres_virtual;
size = fb->x_margin * 2;
for (q = fb_base + skip_bytes - fb->x_margin, h = 0;
h <= he; q += incr, h++)
memset (q, attr_bgcol(p,s), size);
}
}
}
int main(int argc, char *argv[])
{
if (argc < 2) {
fprintf(stderr, "Usage: %s <buf size>\n", argv[0]);
exit(EXIT_FAILURE);
}
size_t size = atoi(argv[1]) * 1024;
char *buf = mmap(
NULL, size,
PROT_READ | PROT_WRITE,
//MAP_SHARED | MAP_ANONYMOUS,
//MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB,
MAP_PRIVATE | MAP_ANONYMOUS,
0, 0
);
if (buf == MAP_FAILED) {
perror("mmap");
exit(EXIT_FAILURE);
}
mymemset(buf, 9, size);
double times[COUNT];
struct timespec start, end;
for (int n = 0; n < COUNT; n++) {
clflush_buff(buf, size);
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start);
#ifdef NT
mymemsetnt(buf, 1, size);
#else
mymemset(buf, 1, size);
#endif
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end);
times[n] = ((double) timediff_ts(start, end));
}
double timeS;
double sizeGB = (double)size / 1024 / 1024 / 1024;
printf("%zd", size/1024);
for (int n = 0; n < COUNT; n++) {
timeS = times[n] / 1000 / 1000 / 1000;
printf(" %g", sizeGB/timeS);
}
exit(EXIT_SUCCESS);
}
static void SWRB_WheelTestInit(void)
{
u8 i;
char *str;
gSwrbTestRuningTaskPrio = SWRB_WHEEL_TEST_TASK_PRIO;
str = "\r\n>>>WHEEL TEST<<<\r\n";
SWRB_TestDataFileWriteString(str);
#ifdef _SHOW_TEST_TITLE
MultiEdit_Set_Text_Color(GUI_BLACK);
MultiEdit_Add_Text(hWin_SWRB_PCBTEST, ID_PCBTEST_MULTIEDIT_MAIN, str);
#endif
SWRB_TestInitCommonAct(gSwrbTestRuningTaskPrio);
for(i=0;i<SWRB_WHEEL_CHAN_NUM;i++){
mymemset(&wheel[i], 0, sizeof(wheel[i]));
}
printf("WHL->DIR=1\r\n");
OSTimeDlyHMSM(0,0,0,SWRB_TEST_USART_WRITE_WAIT_TIME);
printf("LW->SPD=50\r\n");
OSTimeDlyHMSM(0,0,0,SWRB_TEST_USART_WRITE_WAIT_TIME);
printf("RW->SPD=50\r\n");
/*
printf("WHL->ON=%d\r\n",WHEEL_CHAN_L);
OSTimeDlyHMSM(0,0,0,SWRB_TEST_USART_WRITE_WAIT_TIME);
printf("WHL->ON=%d\r\n",WHEEL_CHAN_R);
*/
OSTimeDlyHMSM(0,0,0,SWRB_TEST_TASK_INIT_WAIT_TIME_MS);
}
static void validate_memset(void)
{
size_t dstalign, size;
int c;
const size_t maxsize = 256;
printf("testing memset for correctness\n");
for (dstalign = 0; dstalign < 64; dstalign++) {
printf("align %zd\n", dstalign);
for (size = 0; size < maxsize; size++) {
for (c = 0; c < 256; c++) {
fillbuf(dst, maxsize * 2, 123514);
fillbuf(dst2, maxsize * 2, 123514);
memset(dst + dstalign, c, size);
mymemset(dst2 + dstalign, c, size);
int comp = memcmp(dst, dst2, maxsize * 2);
if (comp != 0) {
printf("error! align %zu, c %d, size %zu\n", dstalign, c, size);
}
}
}
}
}
static void SWRB_BrushTestTaskInit(void)
{
u8 i;
char *str;
gSwrbTestRuningTaskPrio = SWRB_BRUSH_TEST_TASK_PRIO;
str = "\r\n>>>BRUSH TEST<<<\r\n";
SWRB_TestDataFileWriteString(str);
#ifdef _SHOW_TEST_TITLE
MultiEdit_Set_Text_Color(GUI_BLACK);
MultiEdit_Add_Text(hWin_SWRB_PCBTEST, ID_PCBTEST_MULTIEDIT_MAIN, str);
#endif
SWRB_TestInitCommonAct(gSwrbTestRuningTaskPrio);
for(i=0;i<SWRB_BRUSH_CHAN_NUM;i++){
mymemset(&brush[i], 0, sizeof(brush[i]));
}
printf("LB->SPD=100\r\n");
OSTimeDlyHMSM(0,0,0,SWRB_TEST_USART_WRITE_WAIT_TIME);
printf("RB->SPD=100\r\n");
OSTimeDlyHMSM(0,0,0,SWRB_TEST_USART_WRITE_WAIT_TIME);
printf("MB->SPD=60\r\n");
OSTimeDlyHMSM(0,0,0,SWRB_TEST_USART_WRITE_WAIT_TIME);
OSTimeDlyHMSM(0,0,0,SWRB_TEST_TASK_INIT_WAIT_TIME_MS);
}
int main()
{
char *ptr;
ptr=(char *)malloc(sizeof(char));
mymemset(ptr,'a',sizeof(ptr));
puts(ptr);
}
//得到LZW的下一个码
//返回值:<0,错误(-1,不成功;-2,读到结束符了)
// >=0,OK.(LZW的第一个码)
int gif_getnextbyte(FIL *gfile,gif89a* gif)
{
int i,Code,Incode;
while((Code=gif_getnextcode(gfile,gif))>=0)
{
if(Code==gif->lzw->ClearCode)
{
//Corrupt GIFs can make this happen
if(gif->lzw->ClearCode>=(1<<MAX_NUM_LWZ_BITS))return -1;//Error
//Clear the tables
mymemset((u8*)gif->lzw->aCode,0,sizeof(gif->lzw->aCode));
for(i=0;i<gif->lzw->ClearCode;++i)gif->lzw->aPrefix[i]=i;
//Calculate the'special codes' independence of the initial code size
//and initialize the stack pointer
gif->lzw->CodeSize=gif->lzw->SetCodeSize+1;
gif->lzw->MaxCodeSize=gif->lzw->ClearCode<<1;
gif->lzw->MaxCode=gif->lzw->ClearCode+2;
gif->lzw->sp=gif->lzw->aDecompBuffer;
//Read the first code from the stack after clear ingand initializing*/
do
{
gif->lzw->FirstCode=gif_getnextcode(gfile,gif);
}while(gif->lzw->FirstCode==gif->lzw->ClearCode);
gif->lzw->OldCode=gif->lzw->FirstCode;
return gif->lzw->FirstCode;
}
if(Code==gif->lzw->EndCode)return -2;//End code
Incode=Code;
if(Code>=gif->lzw->MaxCode)
{
*(gif->lzw->sp)++=gif->lzw->FirstCode;
Code=gif->lzw->OldCode;
}
while(Code>=gif->lzw->ClearCode)
{
*(gif->lzw->sp)++=gif->lzw->aPrefix[Code];
if(Code==gif->lzw->aCode[Code])return Code;
if((gif->lzw->sp-gif->lzw->aDecompBuffer)>=sizeof(gif->lzw->aDecompBuffer))return Code;
Code=gif->lzw->aCode[Code];
}
*(gif->lzw->sp)++=gif->lzw->FirstCode=gif->lzw->aPrefix[Code];
if((Code=gif->lzw->MaxCode)<(1<<MAX_NUM_LWZ_BITS))
{
gif->lzw->aCode[Code]=gif->lzw->OldCode;
gif->lzw->aPrefix[Code]=gif->lzw->FirstCode;
++gif->lzw->MaxCode;
if((gif->lzw->MaxCode>=gif->lzw->MaxCodeSize)&&(gif->lzw->MaxCodeSize<(1<<MAX_NUM_LWZ_BITS)))
{
gif->lzw->MaxCodeSize<<=1;
++gif->lzw->CodeSize;
}
}
gif->lzw->OldCode=Incode;
if(gif->lzw->sp>gif->lzw->aDecompBuffer)return *--(gif->lzw->sp);
}
return Code;
}
int main()
{
myopen
freopen("test.txt", "r", stdin);
int t = 0;
scanf("%d", &t);
while (t--)
{
mymemset(positive_data);
mymemset(negative_num);
int n = 0, datanum = 0, i = 0;
scanf("%d", &n);
for (i = 0; i < n; ++i)
{
scanf("%d", &datanum);
if (datanum > 0)
{
++positive_data[datanum];
if (positive_data[datanum] > n / 2) {
break;
}
}
else
{
++negative_num[-datanum];
if (negative_num[-datanum] > n / 2) {
break;
}
}
}
while (i + 1 < n)
{
i++;
int excess = 0;
scanf("%d", &excess);
// printf("%d\n", excess );
}
if (i != n)
printf("%d\n", datanum);
else
printf("no\n");
}
}
/* Internal constructor. */
static cJSON *cJSON_New_Item(void)
{
cJSON* node = (cJSON*)cJSON_malloc(sizeof(cJSON));
if (node)
{
mymemset(node,0,sizeof(cJSON));
}
return node;
}
//存在着页面访问异常，目前不知道原因
void* cJSON_malloc(size_t sz)
{
void* p = hx_malloc(sz);
if(p)
{
mymemset(p,0,sz);
}
return p;
}
void fbcon_mfb_clear(struct vc_data *conp, struct display *p, int sy, int sx,
int height, int width)
{
u8 *dest;
u_int rows;
int inverse = conp ? attr_reverse(p,conp->vc_video_erase_char) : 0;
dest = p->screen_base+sy*fontheight(p)*p->next_line+sx;
if (sx == 0 && width == p->next_line) {
if (inverse)
mymemset(dest, height*fontheight(p)*width);
else
mymemclear(dest, height*fontheight(p)*width);
} else
for (rows = height*fontheight(p); rows--; dest += p->next_line)
if (inverse)
mymemset(dest, width);
else
mymemclear_small(dest, width);
}
//初始化LZW相关参数
//gif:gif信息;
//codesize:lzw码长度
void gif_initlzw(gif89a* gif,u8 codesize)
{
mymemset((u8 *)gif->lzw, 0, sizeof(LZW_INFO));
gif->lzw->SetCodeSize = codesize;
gif->lzw->CodeSize = codesize + 1;
gif->lzw->ClearCode = (1 << codesize);
gif->lzw->EndCode = (1 << codesize) + 1;
gif->lzw->MaxCode = (1 << codesize) + 2;
gif->lzw->MaxCodeSize = (1 << codesize) << 1;
gif->lzw->ReturnClear = 1;
gif->lzw->LastByte = 2;
gif->lzw->sp = gif->lzw->aDecompBuffer;
}
u8 exfans_init(void)
{
u8 i;
for(i=0;i<_VOLUMES;i++)
{
fs[i]=(FATFS*)mymalloc(SRAMEX,sizeof(FATFS));
mymemset(fs[i], 0, sizeof(FATFS));
if(!fs[i])break;
}
// file=(FIL*)mymalloc(SRAMEX,sizeof(FIL));
// size = sizeof(FIL);
// mymemset(file, 0, sizeof(FIL));
/* Use actual sizeof FIL to malloc file to avoid wrong malloc size */
file=(FIL*)mymalloc(SRAMEX,1101);
mymemset(file, 0, 1101);
ftemp=(FIL*)mymalloc(SRAMEX,sizeof(FIL));
mymemset(ftemp, 0, sizeof(FIL));
fatbuf=(u8*)mymalloc(SRAMEX,4096);
mymemset(fatbuf, 0, 4096);
if(i==_VOLUMES&&file&&ftemp&&fatbuf)return 0;
else return 1;
}
void SaveScreenShotNow(void)
{
FILE *fout;
void *dest, *source;
static unsigned long screenshotcnt = 0;
unsigned int page = 0;
signed int scr_size = 640*480; // for svga
unsigned long xdim, ydim;
char *GP2_Zielpalette = (void *) IDACodeReftoDataRef(0x7f624);
unsigned char *GP2_use_svga = (void *) IDACodeReftoDataRef(0x35b36);
//---- determine the dims (and allocate svga buffer) ------
if (*GP2_use_svga) {
xdim = 640; ydim = 480;
}
else {
xdim = 320; ydim = 200;
}
//---- fill workbuf, or if it's VGA it's still there ------
if (*GP2_use_svga) {
source = (unsigned char *)0x000A0000;
dest = &picbuf;
while(scr_size > 0) {
vesa_setpage(page, GetSvgaGranularity() /*64*/);
mymemcpy(dest, source, (scr_size > 65536 ? 65536 : scr_size));
scr_size -= 65536;
dest = (void *)((unsigned long)dest + 65536);
page++;
}
dest = &picbuf;
}
else
dest = (unsigned char *)0x000A0000;
//---- now write dest to file ------
_bprintf(atmp, sizeof(atmp), "gp2_%04u.bmp", screenshotcnt++);
if ((fout = fopen(atmp, "wb")) != NULL) {
savestream_svgabmp(dest, 0 /*xpos*/, 0 /*ypos*/, xdim, ydim,
GP2_Zielpalette, fout);
fclose(fout);
}
mymemset(&picbuf, 0, sizeof(picbuf));
ReDrawAllPages(NULL);
} // SaveScreenShotNow()
int32 ReadStr(EdpPacket* pkg, char** val)
{
uint16 len;
/* read str len */
int rc = ReadUint16(pkg, &len);
if (rc)
return rc;
if (pkg->_read_pos+len > pkg->_write_pos)
return -1;
/* copy str val */
*val = (char*)hx_malloc(sizeof(char) * (len + 1));
mymemset(*val, 0, len+1);
strncpy(*val, (const char *)(pkg->_data + pkg->_read_pos), len);
pkg->_read_pos += len;
return 0;
}
int main(void)
{
char *c = malloc(SIZE);
#ifdef NT
mymemsetnt(c+OFFSET, 'a', SIZE-OFFSET);
#else
mymemset(c+OFFSET, 'a', SIZE-OFFSET);
#endif
for (int i = 0; i+OFFSET < SIZE; i++) {
assert(c[i+OFFSET] == 'a');
}
free(c);
puts("OK!");
return 0;
}
int main(int argc, char *argv[])
{
char buf[BUF_SIZE] = {0};
int i = 0;
mymemset(buf, '\x52', BUF_SIZE); // oct '\052' = *, hex '\x52' = R
while(i++<BUF_SIZE){
printf("%c", buf[i-1]); // NOTICE: the i is start from 1
fflush(NULL);
if(0 == (i&7)){ // NOTICE: the priority of == and &
putchar('\n');
fflush(NULL);
}
}
putchar('\n');
fflush(NULL);
return 0;
}
char * getALineCode(FIL *m_file)
{
mymemset(str,'\0',96);
if ((f_gets(str,96,m_file)!=NULL))//?????
{
tempNum++;
return str;
}
else{
printf("\r\nFile read over!\n");
return NULL;
}
}
void fbcon_ilbm_clear(struct vc_data *conp, struct display *p, int sy, int sx,
int height, int width)
{
u8 *dest;
u_int i, rows;
int bg, bg0;
dest = p->screen_base+sy*fontheight(p)*p->next_line+sx;
bg0 = attr_bgcol_ec(p,conp);
for (rows = height*fontheight(p); rows--;) {
bg = bg0;
for (i = p->var.bits_per_pixel; i--; dest += p->next_plane) {
if (bg & 1)
mymemset(dest, width);
else
mymemclear(dest, width);
bg >>= 1;
}
}
}
void fbcon_mfb_clear_margins(struct vc_data *conp, struct display *p,
int bottom_only)
{
u8 *dest;
int height, bottom;
int inverse = conp ? attr_reverse(p,conp->vc_video_erase_char) : 0;
/* XXX Need to handle right margin? */
height = p->var.yres - conp->vc_rows * fontheight(p);
if (!height)
return;
bottom = conp->vc_rows + p->yscroll;
if (bottom >= p->vrows)
bottom -= p->vrows;
dest = p->screen_base + bottom * fontheight(p) * p->next_line;
if (inverse)
mymemset(dest, height * p->next_line);
else
mymemclear(dest, height * p->next_line);
}
//内存管理初始化
void mem_init(void)
{
mymemset(mallco_dev.memmap, 0,memtblsize*2);//内存状态表数据清零
mymemset(mallco_dev.membase, 0,memsize); //内存池所有数据清零
mallco_dev.memrdy=1; //内存管理初始化OK
}
//内存管理初始化
//memx:所属内存块
void mem_init(u8 memx)
{
mymemset(mallco_dev.memmap[memx], 0,memtblsize[memx]*2);//内存状态表数据清零
mymemset(mallco_dev.membase[memx], 0,memsize[memx]); //内存池所有数据清零
mallco_dev.memrdy[memx]=1; //内存管理初始化OK
}
//内存管理初始化
//memx:所属内存块
static void my_mem_init(uint8_t memx)
{
/*mallco_dev.memmap[memx]表示存储块的末尾地址*/
mymemset(mallco_dev.memmap[memx],0,memtblsize[memx]*4); //内存状态表数据清零
mallco_dev.memrdy[memx]=1; //内存管理初始化OK
}
int main(int argc, char **argv)
{
FILE *out; /* Output data file */
char s[255],s2[255],delim[255],*pstr; /* Generic strings */
int *memcache; /* used to flush cache */
int len_buf_align, /* meaningful when args.cache is 0. buflen */
/* rounded up to be divisible by 8 */
num_buf_align; /* meaningful when args.cache is 0. number */
/* of aligned buffers in memtmp */
int c, /* option index */
i, j, n, nq, /* Loop indices */
asyncReceive=0, /* Pre-post a receive buffer? */
bufalign=16*1024,/* Boundary to align buffer to */
errFlag, /* Error occurred in inner testing loop */
nrepeat, /* Number of time to do the transmission */
nrepeat_const=0,/* Set if we are using a constant nrepeat */
len, /* Number of bytes to be transmitted */
inc=0, /* Increment value */
perturbation=DEFPERT, /* Perturbation value */
pert,
start= 1, /* Starting value for signature curve */
end=MAXINT, /* Ending value for signature curve */
streamopt=0, /* Streaming mode flag */
reset_connection;/* Reset the connection between trials */
ArgStruct args; /* Arguments for all the calls */
double t, t0, t1, t2, /* Time variables */
tlast, /* Time for the last transmission */
latency; /* Network message latency */
Data bwdata[NSAMP]; /* Bandwidth curve data */
int integCheck=0; /* Integrity check */
/* Initialize vars that may change from default due to arguments */
strcpy(s, "np.out"); /* Default output file */
/* Let modules initialize related vars, and possibly call a library init
function that requires argc and argv */
Init(&args, &argc, &argv); /* This will set args.tr and args.rcv */
args.preburst = 0; /* Default to not bursting preposted receives */
args.bidir = 0; /* Turn bi-directional mode off initially */
args.cache = 1; /* Default to use cache */
args.upper = end;
args.host = NULL;
args.soffset=0; /* default to no offsets */
args.roffset=0;
args.syncflag=0; /* use normal mpi_send */
args.port = DEFPORT; /* just in case the user doesn't set this. */
/* TCGMSG launches NPtcgmsg with a -master master_hostname
* argument, so ignore all arguments and set them manually
* in netpipe.c instead.
*/
#if ! defined(TCGMSG)
/* Parse the arguments. See Usage for description */
while ((c = getopt(argc, argv, "SO:rIiszgfaB2h:p:o:l:u:b:m:n:t:c:d:D:P:")) != -1)
{
switch(c)
{
case 'O':
strcpy(s2,optarg);
strcpy(delim,",");
if((pstr=strtok(s2,delim))!=NULL) {
args.soffset=atoi(pstr);
if((pstr=strtok((char *)NULL,delim))!=NULL)
args.roffset=atoi(pstr);
else /* only got one token */
args.roffset=args.soffset;
} else {
args.soffset=0; args.roffset=0;
}
printf("Transmit buffer offset: %d\nReceive buffer offset: %d\n",args.soffset,args.roffset);
break;
case 'p': perturbation = atoi(optarg);
if( perturbation > 0 ) {
printf("Using a perturbation value of %d\n\n", perturbation);
} else {
perturbation = 0;
printf("Using no perturbations\n\n");
}
break;
case 'B': if(integCheck == 1) {
fprintf(stderr, "Integrity check not supported with prepost burst\n");
exit(-1);
}
args.preburst = 1;
asyncReceive = 1;
printf("Preposting all receives before a timed run.\n");
printf("Some would consider this cheating,\n");
printf("but it is needed to match some vendor tests.\n"); fflush(stdout);
break;
case 'I': args.cache = 0;
printf("Performance measured without cache effects\n\n"); fflush(stdout);
break;
case 'o': strcpy(s,optarg);
printf("Sending output to %s\n", s); fflush(stdout);
break;
case 's': streamopt = 1;
printf("Streaming in one direction only.\n\n");
#if defined(TCP) && ! defined(INFINIBAND)
printf("Sockets are reset between trials to avoid\n");
printf("degradation from a collapsing window size.\n\n");
#endif
args.reset_conn = 1;
printf("Streaming does not provide an accurate\n");
printf("measurement of the latency since small\n");
printf("messages may get bundled together.\n\n");
if( args.bidir == 1 ) {
printf("You can't use -s and -2 together\n");
exit(0);
}
fflush(stdout);
break;
case 'l': start = atoi(optarg);
if (start < 1)
{
fprintf(stderr,"Need a starting value >= 1\n");
exit(0);
}
break;
case 'u': end = atoi(optarg);
break;
#if defined(TCP) && ! defined(INFINIBAND)
case 'b': /* -b # resets the buffer size, -b 0 keeps system defs */
args.prot.sndbufsz = args.prot.rcvbufsz = atoi(optarg);
break;
#endif
case '2': args.bidir = 1; /* Both procs are transmitters */
/* end will be maxed at sndbufsz+rcvbufsz */
printf("Passing data in both directions simultaneously.\n");
printf("Output is for the combined bandwidth.\n");
#if defined(TCP) && ! defined(INFINIBAND)
printf("The socket buffer size limits the maximum test size.\n\n");
#endif
if( streamopt ) {
printf("You can't use -s and -2 together\n");
exit(0);
}
break;
case 'h': args.tr = 1; /* -h implies transmit node */
args.rcv = 0;
args.host = (char *)malloc(strlen(optarg)+1);
strcpy(args.host, optarg);
break;
#ifdef DISK
case 'd': args.tr = 1; /* -d to specify input/output file */
args.rcv = 0;
args.prot.read = 0;
args.prot.read_type = 'c';
args.prot.dfile_name = (char *)malloc(strlen(optarg)+1);
strcpy(args.prot.dfile_name, optarg);
break;
case 'D': if( optarg[0] == 'r' )
args.prot.read = 1;
else
args.prot.read = 0;
args.prot.read_type = optarg[1];
break;
#endif
case 'i': if(args.preburst == 1) {
fprintf(stderr, "Integrity check not supported with prepost burst\n");
exit(-1);
}
integCheck = 1;
perturbation = 0;
start = sizeof(int)+1; /* Start with integer size */
printf("Doing an integrity check instead of measuring performance\n"); fflush(stdout);
break;
#if defined(MPI)
case 'z': args.source_node = -1;
printf("Receive using the ANY_SOURCE flag\n"); fflush(stdout);
break;
case 'a': asyncReceive = 1;
printf("Preposting asynchronous receives\n"); fflush(stdout);
break;
case 'S': args.syncflag=1;
fprintf(stderr,"Using synchronous sends\n");
break;
#endif
#if defined(MPI2)
case 'g': if(args.prot.no_fence == 1) {
fprintf(stderr, "-f cannot be used with -g\n");
exit(-1);
}
args.prot.use_get = 1;
printf("Using MPI-2 Get instead of Put\n");
break;
case 'f': if(args.prot.use_get == 1) {
fprintf(stderr, "-f cannot be used with -g\n");
exit(-1);
}
args.prot.no_fence = 1;
bufalign = 0;
printf("Buffer alignment off (Required for no fence)\n");
break;
#endif /* MPI2 */
#if defined(INFINIBAND)
case 'm': switch(atoi(optarg)) {
case 256: args.prot.ib_mtu = MTU256;
break;
case 512: args.prot.ib_mtu = MTU512;
break;
case 1024: args.prot.ib_mtu = MTU1024;
break;
case 2048: args.prot.ib_mtu = MTU2048;
break;
case 4096: args.prot.ib_mtu = MTU4096;
break;
default:
fprintf(stderr, "Invalid MTU size, must be one of "
"256, 512, 1024, 2048, 4096\n");
exit(-1);
}
break;
case 't': if( !strcmp(optarg, "send_recv") ) {
printf("Using Send/Receive communications\n");
args.prot.commtype = NP_COMM_SENDRECV;
} else if( !strcmp(optarg, "send_recv_with_imm") ) {
printf("Using Send/Receive communications with immediate data\n");
args.prot.commtype = NP_COMM_SENDRECV_WITH_IMM;
} else if( !strcmp(optarg, "rdma_write") ) {
printf("Using RDMA Write communications\n");
args.prot.commtype = NP_COMM_RDMAWRITE;
} else if( !strcmp(optarg, "rdma_write_with_imm") ) {
printf("Using RDMA Write communications with immediate data\n");
args.prot.commtype = NP_COMM_RDMAWRITE_WITH_IMM;
} else {
fprintf(stderr, "Invalid transfer type "
"specified, please choose one of:\n\n"
"\tsend_recv\t\tUse Send/Receive communications\t(default)\n"
"\tsend_recv_with_imm\tSame as above with immediate data\n"
"\trdma_write\t\tUse RDMA Write communications\n"
"\trdma_write_with_imm\tSame as above with immediate data\n\n");
exit(-1);
}
break;
case 'c': if( !strcmp(optarg, "local_poll") ) {
printf("Using local polling completion\n");
args.prot.comptype = NP_COMP_LOCALPOLL;
} else if( !strcmp(optarg, "vapi_poll") ) {
printf("Using VAPI polling completion\n");
args.prot.comptype = NP_COMP_VAPIPOLL;
} else if( !strcmp(optarg, "event") ) {
printf("Using VAPI event completion\n");
args.prot.comptype = NP_COMP_EVENT;
} else {
fprintf(stderr, "Invalid completion type specified, "
"please choose one of:\n\n"
"\tlocal_poll\tWait for last byte of data\t(default)\n"
"\tvapi_poll\tUse VAPI polling function\n"
"\tevent\t\tUse VAPI event handling function\n\n");
exit(-1);
}
break;
#endif
case 'n': nrepeat_const = atoi(optarg);
break;
#if defined(TCP) && ! defined(INFINIBAND)
case 'r': args.reset_conn = 1;
printf("Resetting connection after every trial\n");
break;
#endif
case 'P':
args.port = atoi(optarg);
break;
default:
PrintUsage();
exit(-12);
}
}
#endif /* ! defined TCGMSG */
#if defined(INFINIBAND)
asyncReceive = 1;
fprintf(stderr, "Preposting asynchronous receives (required for Infiniband)\n");
if(args.bidir && (
(args.cache && args.prot.commtype == NP_COMM_RDMAWRITE) || /* rdma_write only works with no-cache mode */
(!args.preburst && args.prot.commtype != NP_COMM_RDMAWRITE) || /* anything besides rdma_write requires prepost burst */
(args.preburst && args.prot.comptype == NP_COMP_LOCALPOLL && args.cache) || /* preburst with local polling in cache mode doesn't work */
0)) {
fprintf(stderr,
"\n"
"Bi-directional mode currently only works with a subset of the\n"
"Infiniband options. Restrictions are:\n"
"\n"
" RDMA write (-t rdma_write) requires no-cache mode (-I).\n"
"\n"
" Local polling (-c local_poll, default if no -c given) requires\n"
" no-cache mode (-I), and if not using RDMA write communication,\n"
" burst mode (-B).\n"
"\n"
" Any other communication type and any other completion type\n"
" require burst mode (-B). No-cache mode (-I) may be used\n"
" optionally.\n"
"\n"
" All other option combinations will fail.\n"
"\n");
exit(-1);
}
#endif
if (start > end)
{
fprintf(stderr, "Start MUST be LESS than end\n");
exit(420132);
}
args.nbuff = TRIALS;
Setup(&args);
if( args.bidir && end > args.upper ) {
end = args.upper;
if( args.tr ) {
printf("The upper limit is being set to %d Bytes\n", end);
#if defined(TCP) && ! defined(INFINIBAND)
printf("due to socket buffer size limitations\n\n");
#endif
} }
#if defined(GM)
if(streamopt && (!nrepeat_const || nrepeat_const > args.prot.num_stokens)) {
printf("\nGM is currently limited by the driver software to %d\n",
args.prot.num_stokens);
printf("outstanding sends. The number of repeats will be set\n");
printf("to this limit for every trial in streaming mode. You\n");
printf("may use the -n switch to set a smaller number of repeats\n\n");
nrepeat_const = args.prot.num_stokens;
}
#endif
if( args.tr ) /* Primary transmitter */
{
if ((out = fopen(s, "w")) == NULL)
{
fprintf(stderr,"Can't open %s for output\n", s);
exit(1);
}
}
else out = stdout;
/* Set a starting value for the message size increment. */
inc = (start > 1) ? start / 2 : 1;
nq = (start > 1) ? 1 : 0;
/* Test the timing to set tlast for the first test */
args.bufflen = start;
MyMalloc(&args, args.bufflen, 0, 0);
InitBufferData(&args, args.bufflen, 0, 0);
if(args.cache) args.s_buff = args.r_buff;
args.r_ptr = args.r_buff_orig = args.r_buff;
args.s_ptr = args.s_buff_orig = args.s_buff;
AfterAlignmentInit(&args); /* MPI-2 needs this to create a window */
/* Infiniband requires use of asynchronous communications, so we need
* the PrepareToReceive calls below
*/
if( asyncReceive )
PrepareToReceive(&args);
Sync(&args); /* Sync to prevent race condition in armci module */
/* For simplicity's sake, even if the real test below will be done in
* bi-directional mode, we still do the ping-pong one-way-at-a-time test
* here to estimate the one-way latency. Unless it takes significantly
* longer to send data in both directions at once than it does to send data
* one way at a time, this shouldn't be too far off anyway.
*/
t0 = When();
for( n=0; n<100; n++) {
if( args.tr) {
SendData(&args);
RecvData(&args);
if( asyncReceive && n<99 )
PrepareToReceive(&args);
} else if( args.rcv) {
RecvData(&args);
if( asyncReceive && n<99 )
PrepareToReceive(&args);
SendData(&args);
}
}
tlast = (When() - t0)/200;
/* Sync up and Reset before freeing the buffers */
Sync(&args);
Reset(&args);
/* Free the buffers and any other module-specific resources. */
if(args.cache)
FreeBuff(args.r_buff_orig, NULL);
else
FreeBuff(args.r_buff_orig, args.s_buff_orig);
/* Do setup for no-cache mode, using two distinct buffers. */
if (!args.cache)
{
/* Allocate dummy pool of memory to flush cache with */
if ( (memcache = (int *)malloc(MEMSIZE)) == NULL)
{
perror("malloc");
exit(1);
}
mymemset(memcache, 0, MEMSIZE/sizeof(int));
/* Allocate large memory pools */
MyMalloc(&args, MEMSIZE+bufalign, args.soffset, args.roffset);
/* Save buffer addresses */
args.s_buff_orig = args.s_buff;
args.r_buff_orig = args.r_buff;
/* Align buffers */
args.s_buff = AlignBuffer(args.s_buff, bufalign);
args.r_buff = AlignBuffer(args.r_buff, bufalign);
/* Post alignment initialization */
AfterAlignmentInit(&args);
/* Initialize send buffer pointer */
/* both soffset and roffset should be zero if we don't have any offset stuff, so this should be fine */
args.s_ptr = args.s_buff+args.soffset;
args.r_ptr = args.r_buff+args.roffset;
}
/**************************
* Main loop of benchmark *
**************************/
if( args.tr ) fprintf(stderr,"Now starting the main loop\n");
for ( n = 0, len = start, errFlag = 0;
n < NSAMP - 3 && tlast < STOPTM && len <= end && !errFlag;
len = len + inc, nq++ )
{
/* Exponentially increase the block size. */
if (nq > 2) inc = ((nq % 2))? inc + inc: inc;
/* This is a perturbation loop to test nearby values */
for (pert = ((perturbation > 0) && (inc > perturbation+1)) ? -perturbation : 0;
pert <= perturbation;
n++, pert += ((perturbation > 0) && (inc > perturbation+1)) ? perturbation : perturbation+1)
{
Sync(&args); /* Sync to prevent race condition in armci module */
/* Calculate how many times to repeat the experiment. */
if( args.tr )
{
if (nrepeat_const) {
nrepeat = nrepeat_const;
/* } else if (len == start) {*/
/* nrepeat = MAX( RUNTM/( 0.000020 + start/(8*1000) ), TRIALS);*/
} else {
nrepeat = MAX((RUNTM / ((double)args.bufflen /
(args.bufflen - inc + 1.0) * tlast)),TRIALS);
}
SendRepeat(&args, nrepeat);
}
else if( args.rcv )
{
RecvRepeat(&args, &nrepeat);
}
args.bufflen = len + pert;
if( args.tr )
fprintf(stderr,"%3d: %7d bytes %6d times --> ",
n,args.bufflen,nrepeat);
if (args.cache) /* Allow cache effects. We use only one buffer */
{
/* Allocate the buffer with room for alignment*/
MyMalloc(&args, args.bufflen+bufalign, args.soffset, args.roffset);
/* Save buffer address */
args.r_buff_orig = args.r_buff;
args.s_buff_orig = args.r_buff;
/* Align buffer */
args.r_buff = AlignBuffer(args.r_buff, bufalign);
args.s_buff = args.r_buff;
/* Initialize buffer with data
*
* NOTE: The buffers should be initialized with some sort of
* valid data, whether it is actually used for anything else,
* to get accurate results. Performance increases noticeably
* if the buffers are left uninitialized, but this does not
* give very useful results as realworld apps tend to actually
* have data stored in memory. We are not sure what causes
* the difference in performance at this time.
*/
InitBufferData(&args, args.bufflen, args.soffset, args.roffset);
/* Post-alignment initialization */
AfterAlignmentInit(&args);
/* Initialize buffer pointers (We use r_ptr and s_ptr for
* compatibility with no-cache mode, as this makes the code
* simpler)
*/
/* offsets are zero by default so this saves an #ifdef */
args.r_ptr = args.r_buff+args.roffset;
args.s_ptr = args.r_buff+args.soffset;
}
else /* Eliminate cache effects. We use two distinct buffers */
{
/* this isn't truly set up for offsets yet */
/* Size of an aligned memory block including trailing padding */
len_buf_align = args.bufflen;
if(bufalign != 0)
len_buf_align += bufalign - args.bufflen % bufalign;
/* Initialize the buffers with data
*
* See NOTE above.
*/
InitBufferData(&args, MEMSIZE, args.soffset, args.roffset);
/* Reset buffer pointers to beginning of pools */
args.r_ptr = args.r_buff+args.roffset;
args.s_ptr = args.s_buff+args.soffset;
}
bwdata[n].t = LONGTIME;
/* t2 = t1 = 0;*/
/* Finally, we get to transmit or receive and time */
/* NOTE: If a module is running that uses only one process (e.g.
* memcpy), we assume that it will always have the args.tr flag
* set. Thus we make some special allowances in the transmit
* section that are not in the receive section.
*/
if( args.tr || args.bidir )
{
/*
This is the transmitter: send the block TRIALS times, and
if we are not streaming, expect the receiver to return each
block.
*/
for (i = 0; i < (integCheck ? 1 : TRIALS); i++)
{
if(args.preburst && asyncReceive && !streamopt)
{
/* We need to save the value of the recv ptr so
* we can reset it after we do the preposts, in case
* the module needs to use the same ptr values again
* so it can wait on the last byte to change to indicate
* the recv is finished.
*/
SaveRecvPtr(&args);
for(j=0; j<nrepeat; j++)
{
PrepareToReceive(&args);
if(!args.cache)
AdvanceRecvPtr(&args, len_buf_align);
}
ResetRecvPtr(&args);
}
/* Flush the cache using the dummy buffer */
if (!args.cache)
flushcache(memcache, MEMSIZE/sizeof(int));
Sync(&args);
t0 = When();
for (j = 0; j < nrepeat; j++)
{
if (!args.preburst && asyncReceive && !streamopt)
{
PrepareToReceive(&args);
}
if (integCheck) SetIntegrityData(&args);
SendData(&args);
if (!streamopt)
{
RecvData(&args);
if (integCheck) VerifyIntegrity(&args);
if(!args.cache)
AdvanceRecvPtr(&args, len_buf_align);
}
/* Wait to advance send pointer in case RecvData uses
* it (e.g. memcpy module).
*/
if (!args.cache)
AdvanceSendPtr(&args, len_buf_align);
}
/* t is the 1-directional trasmission time */
t = (When() - t0)/ nrepeat;
if( !streamopt && !args.bidir) t /= 2; /* Normal ping-pong */
Reset(&args);
/* NOTE: NetPIPE does each data point TRIALS times, bouncing the message
* nrepeats times for each trial, then reports the lowest of the TRIALS
* times. -Dave Turner
*/
bwdata[n].t = MIN(bwdata[n].t, t);
/* t1 += t;*/
/* t2 += t*t;*/
}
if (streamopt){ /* Get time info from Recv node */
RecvTime(&args, &bwdata[n].t);
/* RecvTime(&args, &t1);*/
/* RecvTime(&args, &t2);*/
}
/* Calculate variance after completing this set of trials */
/* bwdata[n].variance = t2/TRIALS - t1/TRIALS * t1/TRIALS;*/
}
else if( args.rcv )
{
/*
This is the receiver: receive the block TRIALS times, and
if we are not streaming, send the block back to the
sender.
*/
for (i = 0; i < (integCheck ? 1 : TRIALS); i++)
{
if (asyncReceive)
{
if (args.preburst)
{
/* We need to save the value of the recv ptr so
* we can reset it after we do the preposts, in case
* the module needs to use the same ptr values again
* so it can wait on the last byte to change to
* indicate the recv is finished.
*/
SaveRecvPtr(&args);
for (j=0; j < nrepeat; j++)
{
PrepareToReceive(&args);
if (!args.cache)
AdvanceRecvPtr(&args, len_buf_align);
}
ResetRecvPtr(&args);
}
else
{
PrepareToReceive(&args);
}
}
/* Flush the cache using the dummy buffer */
if (!args.cache)
flushcache(memcache, MEMSIZE/sizeof(int));
Sync(&args);
t0 = When();
for (j = 0; j < nrepeat; j++)
{
RecvData(&args);
if (integCheck) VerifyIntegrity(&args);
if (!args.cache)
{
AdvanceRecvPtr(&args, len_buf_align);
}
if (!args.preburst && asyncReceive && (j < nrepeat-1))
{
PrepareToReceive(&args);
}
if (!streamopt)
{
if (integCheck) SetIntegrityData(&args);
SendData(&args);
if(!args.cache)
AdvanceSendPtr(&args, len_buf_align);
}
}
t = (When() - t0)/ nrepeat;
if( !streamopt && !args.bidir) t /= 2; /* Normal ping-pong */
Reset(&args);
bwdata[n].t = MIN(bwdata[n].t, t);
/* t1 += t;*/
/* t2 += t*t;*/
}
if (streamopt){ /* Recv proc calcs time and sends to Trans */
SendTime(&args, &bwdata[n].t);
/* SendTime(&args, &t1);*/
/* SendTime(&args, &t2);*/
}
}
else /* Just going along for the ride */
{
for (i = 0; i < (integCheck ? 1 : TRIALS); i++)
{
Sync(&args);
}
}
/* Streaming mode doesn't really calculate correct latencies
* for small message sizes, and on some nics we can get
* zero second latency after doing the math. Protect against
* this.
*/
if(bwdata[n].t == 0.0) {
bwdata[n].t = 0.000001;
}
tlast = bwdata[n].t;
bwdata[n].bits = args.bufflen * CHARSIZE * (1+args.bidir);
bwdata[n].bps = bwdata[n].bits / (bwdata[n].t * 1024 * 1024);
bwdata[n].repeat = nrepeat;
if (args.tr)
{
if(integCheck) {
fprintf(out,"%8d %d", bwdata[n].bits / 8, nrepeat);
} else {
fprintf(out,"%8d %lf %12.8lf",
bwdata[n].bits / 8, bwdata[n].bps, bwdata[n].t);
}
fprintf(out, "\n");
fflush(out);
}
/* Free using original buffer addresses since we may have aligned
r_buff and s_buff */
if (args.cache)
FreeBuff(args.r_buff_orig, NULL);
if ( args.tr ) {
if(integCheck) {
fprintf(stderr, " Integrity check passed\n");
} else {
fprintf(stderr," %8.2lf Mbps in %10.2lf usec\n",
bwdata[n].bps, tlast*1.0e6);
}
}
} /* End of perturbation loop */
} /* End of main loop */
/* Free using original buffer addresses since we may have aligned
r_buff and s_buff */
if (!args.cache) {
FreeBuff(args.s_buff_orig, args.r_buff_orig);
}
if (args.tr) fclose(out);
CleanUp(&args);
return 0;
}
void myip_stream_init(void)
{
st.dir = 0;
mymemset(st.src_ipaddr, 0, 4);
mymemset(st.dst_ipaddr, 0, 4);
}
hidGC extents_make_gc( void )
{
/* phantom */ hidGC rv;
mymemset( malloc( 4 ), 0, 4 );
return *ebp_24;
}
//串口接收数据保存在文件中
//轮询timeout次还没数据读入就退出
//cycletime 读文件时轮询扫描的周期 单位ms
void m_creatFile(char * pathname ,int timeout,u16 cycletime)
{
u8 t=0;
mf_open((u8*)pathname,FA_OPEN_ALWAYS| FA_READ|FA_WRITE);
while(1)
{
/*
---------------------串口状态-------------------------
//串口1中断服务程序
//注意,读取USARTx->SR能避免莫名其妙的错误
//u8 USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.
//接收状态
//bit15， 接收完成标志
//bit14， 接收到0x0d
//bit13~0， 接收到的有效字节数目
//u16 USART_RX_STA=0; //接收状态标记
---------------------FATFS函数-------------------------
//void mymemset(void *s,u8 c,u32 count); //设置内存
//void mymemcpy(void *des,void *src,u32 n);//复制内存
//void myfree(u8 memx,void *ptr); //内存释放(外部调用)
//u8 mf_write(u8*dat,u16 len);
*/
//成功读入一行数据
if(USART_RX_STA&0x8000)
{
//串口收到数据长度
int len = USART_RX_STA&0x3fff;
//开辟空间
char * conn_recv = (char*)mymalloc(SRAMIN,len+1);
mymemset(conn_recv,0,len+1); //设置内存
//取串口的数据
mymemcpy(conn_recv, USART_RX_BUF,len);
//显示到屏幕
com_statusBar(conn_recv);
//发送$$开始的字符串表示文件接收完成
if(conn_recv[0]=='$'&&conn_recv[1]=='$')
{
//关闭文件
mf_close();
//释放内存
myfree(SRAMIN,conn_recv);
//状态复位
USART_RX_STA=0;
//break;
return ;
}
//状态复位
USART_RX_STA=0;
//串口接收到的数据保存到本地
mf_write((u8*)conn_recv,len);
//写换行符\n
mf_write((u8*)"\n",1);
//释放内存
myfree(SRAMIN,conn_recv);
t=0;
}
t++;
//超时退出
if(t == timeout){
return;
}
//串口轮询时间与等于200ms
delay_ms(cycletime);
LED0=!LED0;
}
}
