/* $NetBSD: rf_geometry.c,v 1.1 1998/11/13 04:20:30 oster Exp $ */ /* * Copyright (c) 1995 Carnegie-Mellon University. * All rights reserved. * * Author: Mark Holland * * Permission to use, copy, modify and distribute this software and * its documentation is hereby granted, provided that both the copyright * notice and this permission notice appear in all copies of the * software, derivative works or modified versions, and any portions * thereof, and that both notices appear in supporting documentation. * * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. * * Carnegie Mellon requests users of this software to return to * * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU * School of Computer Science * Carnegie Mellon University * Pittsburgh PA 15213-3890 * * any improvements or extensions that they make and grant Carnegie the * rights to redistribute these changes. */ /* * Changes: * 10/24/91 Changes to support disk bus contention model * (MCH) 1. Added media_done_time param to Access_time() * * 08/18/92 Geometry routines have been modified to support zone-bit * recording. * (AS) 1. Each routine which originally referenced the variable * 'disk->geom->sectors_per_track' has been modified, * since the number of sectors per track varies on disks * with zone-bit recording. */ /* : * Log: rf_geometry.c,v * Revision 1.18 1996/08/11 00:40:57 jimz * fix up broken comment * * Revision 1.17 1996/07/28 20:31:39 jimz * i386netbsd port * true/false fixup * * Revision 1.16 1996/07/18 22:57:14 jimz * port simulator to AIX * * Revision 1.15 1996/06/07 21:33:04 jimz * begin using consistent types for sector numbers, * stripe numbers, row+col numbers, recon unit numbers * * Revision 1.14 1996/06/05 18:06:02 jimz * Major code cleanup. The Great Renaming is now done. * Better modularity. Better typing. Fixed a bunch of * synchronization bugs. Made a lot of global stuff * per-desc or per-array. Removed dead code. * * Revision 1.13 1996/05/30 23:22:16 jimz * bugfixes of serialization, timing problems * more cleanup * * Revision 1.12 1996/05/30 11:29:41 jimz * Numerous bug fixes. Stripe lock release code disagreed with the taking code * about when stripes should be locked (I made it consistent: no parity, no lock) * There was a lot of extra serialization of I/Os which I've removed- a lot of * it was to calculate values for the cache code, which is no longer with us. * More types, function, macro cleanup. Added code to properly quiesce the array * on shutdown. Made a lot of stuff array-specific which was (bogusly) general * before. Fixed memory allocation, freeing bugs. * * Revision 1.11 1996/05/24 22:17:04 jimz * continue code + namespace cleanup * typed a bunch of flags * * Revision 1.10 1996/05/23 00:33:23 jimz * code cleanup: move all debug decls to rf_options.c, all extern * debug decls to rf_options.h, all debug vars preceded by rf_ * * Revision 1.9 1996/05/18 19:51:34 jimz * major code cleanup- fix syntax, make some types consistent, * add prototypes, clean out dead code, et cetera * * Revision 1.8 1995/12/12 18:10:06 jimz * MIN -> RF_MIN, MAX -> RF_MAX, ASSERT -> RF_ASSERT * fix 80-column brain damage in comments * * Revision 1.7 1995/12/01 18:29:34 root * added copyright info * */ #include "rf_types.h" #include "rf_geometry.h" #include "rf_raid.h" #include "rf_general.h" #include "rf_debugMem.h" #define DISK_DB "disk_db" #define DISK_NAME "HP2247" #define ABS_DIFF(a,b) ( ((a)>(b)) ? ((a)-(b)) : ((b)-(a)) ) static RF_GeometryList_t *geom_list = (RF_GeometryList_t *) NULL; RF_TICS_t rf_globalSpinup = 1.5; #define NM_LGTH 80 #define NM_PATN " %80s" static RF_GeometryList_t *Fetch_geometry_db(FILE *fd); static void Format_disk(RF_DiskState_t *disk, long sectors_per_block); static long Find_cyl(RF_SectorNum_t block, RF_DiskState_t *disk); static long Find_track(RF_SectorNum_t block, RF_DiskState_t *disk); static long Find_phys_sector(RF_SectorNum_t block, RF_DiskState_t *disk); static RF_TICS_t Delay_to(RF_TICS_t cur_time, RF_SectorNum_t block, RF_DiskState_t *disk); static RF_TICS_t Seek_time(long to_cyl, long to_track, long from_cyl, long from_track, RF_DiskState_t *disk); static RF_TICS_t Seek(RF_TICS_t cur_time, RF_SectorNum_t block, RF_DiskState_t *disk, long update); static RF_TICS_t Rotate(RF_TICS_t cur_time, RF_SectorNum_t block, RF_DiskState_t *disk, long update); static RF_TICS_t Seek_Rotate(RF_TICS_t cur_time, RF_SectorNum_t block, RF_DiskState_t *disk, long update); static RF_TICS_t GAP(long sec_per_track, RF_DiskState_t *disk); static RF_TICS_t Block_access_time(RF_TICS_t cur_time, RF_SectorNum_t block, RF_SectorCount_t numblocks, RF_DiskState_t *disk, long update); static void Zero_stats(RF_DiskState_t *disk); static RF_TICS_t Update_stats(RF_TICS_t cur_time, RF_TICS_t seek, RF_TICS_t rotate, RF_TICS_t transfer, RF_DiskState_t *disk); static void rf_DiskParam(long numCyls, RF_TICS_t minSeek, RF_TICS_t avgSeek, RF_TICS_t maxSeek, RF_TICS_t *a, RF_TICS_t *b, RF_TICS_t *c); static RF_GeometryList_t *Fetch_geometry_db(fd) FILE *fd; { long ret, lineno; char name[NM_LGTH], title[20]; RF_GeometryList_t * list = (RF_GeometryList_t *) NULL, ** next_ptr = & list; if( RF_MAX_DISKNAME_LENnext = (RF_GeometryList_t *) NULL; RF_Calloc(g, 1, sizeof(RF_Geometry_t), (RF_Geometry_t *)); (*next_ptr)->disk = g; next_ptr = &( (*next_ptr)->next ); /*prep for next iteration */ lineno++; if (fscanf( fd, NM_PATN, name ) != 1) { fprintf(stderr,"Disk DB Error: Can't get disk name from disk db\n"); fprintf(stderr,"lineno=%d\n", lineno); fprintf(stderr,"name=\"%s\"\n", name); exit(1); } lineno++; if ( (fscanf(fd, " tracks per cylinder %ld", &(g->tracks_per_cyl)) != 1) || g->tracks_per_cyl <= 0) { fprintf(stderr,"Disk DB Error: Missing or invalid tracks/cyl for disk %s\n", name); exit(1); } lineno++; if ( (fscanf(fd, " number of disk zones %ld", &(g->num_zones)) != 1) || g->num_zones <= 0) { fprintf(stderr,"Disk DB Error: Missing or invalid number of zones for disk %s\n", name); exit(1); } /* This section of code creates the linked list which contains the disk's zone information. */ g->zbr_data = (RF_ZoneList_t *) NULL; znext_ptr = &(g->zbr_data); num_cylinders = 0; /* This for-loop reads in the cylinder count, the sectors per track, and track skew for each zone on the disk. */ for (i=1; i <= g->num_zones; i++) { lineno++; if ( (fscanf(fd, " number of cylinders in zone %ld", &x) != 1) || x < 1) { fprintf(stderr,"Disk DB Error: Zone %ld: Missing or invalid cyls/zone for disk %s\n", i, name); exit(1); } lineno++; if ( (fscanf(fd, " sectors per track in zone %ld", &y) != 1) || y < 1 ) { fprintf(stderr,"Disk DB Error: Zone %ld: Missing or invalid sectors/track for disk %s\n", i, name); exit(1); } lineno++; if ( (fscanf(fd, " track skew in zone %ld", &z) != 1) || z < 0 ) { fprintf(stderr,"Disk DB Error: Zone %ld: Missing or invalid track skew for disk %s\n",i, name); exit(1); } RF_Calloc(*znext_ptr, 1, sizeof(RF_ZoneList_t), (RF_ZoneList_t *)); (*znext_ptr)->next = (RF_ZoneList_t *) NULL; (*znext_ptr)->zone.num_cylinders = x; (*znext_ptr)->zone.sec_per_track = y; (*znext_ptr)->zone.track_skew = z; (*znext_ptr)->zone.num_sectors = (*znext_ptr)->zone.num_cylinders * g->tracks_per_cyl * (*znext_ptr)->zone.sec_per_track; znext_ptr = &((*znext_ptr)->next); num_cylinders = num_cylinders + x; } /* End of for-loop */ lineno++; if ( (fscanf(fd, " revolution time %f", &tmp_f1) != 1) || tmp_f1 <= 0) { fprintf(stderr,"Disk DB Error: Missing or invalid revolution time for disk %s\n",name); exit(1); } lineno++; if ( (fscanf(fd, " 1 cylinder seek time %f", &tmp_f2 ) != 1) || tmp_f2 <= 0) { fprintf(stderr,"Disk DB Error: Missing or invalid 1-cyl seek time for disk %s\n",name); exit(1); } lineno++; if ( (fscanf(fd, " max stroke seek time %f", &tmp_f3) != 1) || tmp_f3 <= 0) { fprintf(stderr,"Disk DB Error: Missing or invalid max seek time for disk %s\n",name); exit(1); } lineno++; if ( (fscanf(fd, " average seek time %f", &tmp_f4) != 1) || tmp_f4 <= 0) { fprintf(stderr,"Disk DB Error: Missing or invalid avg seek time for disk %s\n",name); exit(1); } lineno++; if ( (fscanf(fd, " time to sleep %f", &tmp_f5) != 1) || tmp_f4 <= 0) { fprintf(stderr,"Disk DB Error: Missing or invalid time to sleep for disk %s\n",name); exit(1); } lineno++; if ( (fscanf(fd, " time to spinup %f", &tmp_f6) != 1) || tmp_f4 <= 0) { fprintf(stderr,"Disk DB Error: Missing or invalid time to sleep for disk %s\n",name); exit(1); } strcpy( g->disk_name, name ); g->revolution_time = tmp_f1; g->seek_one_cyl = tmp_f2; g->seek_max_stroke = tmp_f3; g->seek_avg = tmp_f4; g->time_to_sleep = tmp_f5; g->time_to_spinup = tmp_f6; /* convert disk specs to seek equation coeff */ rf_DiskParam( num_cylinders, g->seek_one_cyl, g->seek_avg, g->seek_max_stroke, &g->seek_sqrt_coeff, &g->seek_linear_coeff, &g->seek_constant_coeff ); } return( list ); } static void Format_disk(disk, sectors_per_block) RF_DiskState_t *disk; long sectors_per_block; { long sector_count = 0; RF_ZoneList_t *z; if( disk == (RF_DiskState_t *) NULL ) RF_PANIC(); if( disk->geom == (RF_Geometry_t *) NULL ) RF_PANIC(); if( sectors_per_block <=0 ) RF_PANIC(); disk->sectors_per_block = sectors_per_block; z = disk->geom->zbr_data; /* This while-loop visits each disk zone and computes the total number of sectors on the disk. */ while (z != (RF_ZoneList_t *) NULL) { sector_count = sector_count + (z->zone.num_cylinders * disk->geom->tracks_per_cyl * z->zone.sec_per_track); z = z->next; } disk->last_block_index = (sector_count / sectors_per_block) - 1; } void rf_InitDisk( disk, disk_db, disk_name, init_cyl, init_track, init_offset, row, col) RF_DiskState_t *disk; char *disk_db; char *disk_name; long init_cyl; long init_track; RF_TICS_t init_offset; int row; int col; { RF_GeometryList_t *gp; FILE *f; RF_ASSERT( disk != (RF_DiskState_t *) NULL ); disk->cur_cyl = init_cyl; disk->cur_track = init_track; disk->index_offset = init_offset; disk->geom = (RF_Geometry_t *) NULL; disk->queueFinishTime = 0.0; disk->lastBlock = 0; disk->row=row; disk->col=col; Zero_stats(disk); if (strncmp(disk_name,"/dev",4 )==0) strcpy(disk_name,"HP2247"); if( geom_list == (RF_GeometryList_t *) NULL ) { f = fopen(disk_db,"r"); if (f == NULL) { fprintf(stderr, "ERROR: RAIDframe could not open disk db %s\n", disk_db); exit(1); } geom_list = Fetch_geometry_db( f ); fclose( f ); } for( gp = geom_list; gp != (RF_GeometryList_t *) NULL; gp = gp->next ) { RF_ASSERT( gp->disk != (RF_Geometry_t *) NULL && gp->disk->disk_name != (char *) NULL ); if( strncmp( disk_name, gp->disk->disk_name, RF_MAX_DISKNAME_LEN ) == 0 ) { disk->geom = gp->disk; break; } } if( disk->geom == (RF_Geometry_t *) NULL ) { fprintf( stderr, "Disk %s not found in database %s\n", disk_name, disk_db ); exit(1); } Format_disk( disk, 1 ); } static long Find_cyl( block, disk ) RF_SectorNum_t block; RF_DiskState_t *disk; { RF_ZoneList_t * z; long tmp; long log_sector = block * disk->sectors_per_block; long cylinder = 0; z = disk->geom->zbr_data; /* This while-loop finds the zone to which log_sector belongs, computes the starting cylinder number of this zone, and computes the sector offset into this zone. */ while (log_sector >= z->zone.num_sectors) { log_sector = log_sector - z->zone.num_sectors; cylinder = cylinder + z->zone.num_cylinders; z = z->next; } /* The cylinder to which log_sector belongs equals the starting cylinder number of its zone plus the cylinder offset into the zone. */ tmp = cylinder + (log_sector / (z->zone.sec_per_track * disk->geom->tracks_per_cyl)); return( tmp ); } static long Find_track( block, disk ) RF_SectorNum_t block; RF_DiskState_t *disk; { RF_ZoneList_t * z; long tmp; long log_sector = block * disk->sectors_per_block; long track = 0; z = disk->geom->zbr_data; /* This while-loop finds the zone to which log_sector belongs, computes the starting track number of this zone, and computes the sector offset into this zone. */ while (log_sector >= z->zone.num_sectors) { log_sector = log_sector - z->zone.num_sectors; track = track + (z->zone.num_cylinders * disk->geom->tracks_per_cyl); z = z->next; } /* The track to which log_sector belongs equals the starting track number of its zone plus the track offset into the zone, modulo the number of tracks per cylinder on the disk. */ tmp = (track + (log_sector / z->zone.sec_per_track)) % disk->geom->tracks_per_cyl; return( tmp ); } /* ** The position of a logical sector relative to the index mark on any track ** is not simple. A simple organization would be: ** ** track 0 : 0, 1, 2, 3, ... N-1 ** track 1 : N,N+1,N+2,N+3, ... 2N-1 ** ^ ** Index mark just before this point ** ** This is not good because sequential access of sectors N-1 then N ** will require a full revolution in between (because track switch requires ** a couple of sectors to recalibrate from embedded servo). So frequently ** sequentially numbered sectors are physically skewed so that the next ** accessible sector after N-1 will be N (with a skew of 2) ** ** track 0 : 0, 1, 2, 3, ... N-1 ** track 1 : 2N-2,2N-1, N, N+1, ... 2N-3 ** ^ ** Index mark just before this point ** ** Layout gets even more complex with cylinder boundaries. Seek time ** is A + B*M where M is the number of cylinders to seek over. On a sequential ** access that crosses a cylinder boundary, the disk will rotate for ** A+B seconds, then "track skew" sectors (inter-sector gaps actually) ** before it can access another sector, so the cylinder to cylinder skew ** is "track skew" + CEIL( sectors_per_track*(A+B)/revolution_time ). ** ** So if sector 0 is 0 sectors from the index mark on the first track, ** where is sector X relative to the index mark on its track? ** ** ( ( X % sectors_per_track ) basic relative position ** ** + track_skew * ( X / sectors_per_track ) skewed for each track ** ** + CEIL( sectors_per_track*(A+B)/revolution_time ) ** * ( X / sectors_per_cylinder ) skewed more for each cyl ** ** ) % sectors_per_track wrapped around in the track ** ** ** */ static long Find_phys_sector(block, disk) RF_SectorNum_t block; RF_DiskState_t *disk; { long phys = 0; RF_ZoneList_t * z; long previous_spt = 1; long sector = block * disk->sectors_per_block; z = disk->geom->zbr_data; /* This while-loop finds the zone to which sector belongs, and computes the physical sector up to that zone. */ while (sector >= z->zone.num_sectors) { sector = sector - z->zone.num_sectors; /* By first multiplying 'phys' by the sectors per track in the current zone divided by the sectors per track in the previous zone, we convert a given physical sector in one zone to an equivalent physical sector in another zone. */ phys = ((phys * z->zone.sec_per_track / previous_spt) + (((z->zone.num_sectors - 1) % z->zone.sec_per_track) + (z->zone.track_skew * z->zone.num_cylinders * disk->geom->tracks_per_cyl) + (long) ceil( (double) z->zone.sec_per_track * (disk->geom->seek_constant_coeff) / disk->geom->revolution_time) * z->zone.num_cylinders)) % z->zone.sec_per_track; previous_spt = z->zone.sec_per_track; z = z->next; } /* The final physical sector equals the physical sector up to the particular zone, plus the physical sector caused by the sector offset into this zone. */ phys = ((phys * z->zone.sec_per_track / previous_spt) + ((sector % z->zone.sec_per_track) + (z->zone.track_skew * (sector / z->zone.sec_per_track)) + (long) ceil( (RF_TICS_t) z->zone.sec_per_track * (disk->geom->seek_constant_coeff) / disk->geom->revolution_time) * (sector / (z->zone.sec_per_track * disk->geom->tracks_per_cyl)))) % z->zone.sec_per_track; return( phys ); } /* ** When each disk starts up, its index mark is a fraction (f) of a rotation ** ahead from its heads (in the direction of rotation). The sector ** under its heads is at a fraction f of a rotation from the index ** mark. After T time has past, T/rotation_time revolutions have occured, so ** the sector under the heads is at a fraction FRAC(f+T/rotation_time) of a ** rotation from the index mark. If the target block is at physical sector ** X relative to its index mark, then it is at fraction (X/sectors_per_track), ** so the rotational delay is ** ((X/sectors_per_track)-FRAC(f+T/rotation_time)) * revolution_time ** if this is positive, otherwise it is ** (1+(X/sectors_per_track)-FRAC(f+T/rotation_time)) * revolution_time */ #define FRAC(a) ( (a) - (long) floor(a) ) static RF_TICS_t Delay_to(cur_time, block, disk) RF_TICS_t cur_time; RF_SectorNum_t block; RF_DiskState_t *disk; { RF_TICS_t tmp; RF_ZoneList_t *z; long sector = block * disk->sectors_per_block; z = disk->geom->zbr_data; /* This while-loop finds the zone to which sector belongs. */ while (sector >= z->zone.num_sectors) { sector = sector - z->zone.num_sectors; z = z->next; } tmp = ( (RF_TICS_t) Find_phys_sector(block,disk)/z->zone.sec_per_track - FRAC(disk->index_offset+cur_time/disk->geom->revolution_time) ) * disk->geom->revolution_time; if( tmp < 0 ) tmp += disk->geom->revolution_time; if( tmp < 0 ) RF_PANIC(); return( tmp ); } /* Hmmm...they seem to be computing the head switch time as * equal to the track skew penalty. Is this an approximation? * (MCH) */ static RF_TICS_t Seek_time( to_cyl, to_track, from_cyl, from_track, disk ) long to_cyl; long to_track; long from_cyl; long from_track; RF_DiskState_t *disk; { long cyls = ABS_DIFF( from_cyl, to_cyl ) - 1; RF_TICS_t seek = 0.0; RF_ZoneList_t * z; /* printf("Seek_time: from_cyl %ld, to_cyl %ld, from_trk %ld, to_trk %ld\n",from_cyl, to_cyl, from_track, to_track); */ if( from_cyl != to_cyl ) { z = disk->geom->zbr_data; /* This while-loop finds the zone to which to_cyl belongs. */ while (to_cyl >= z->zone.num_cylinders) { to_cyl = to_cyl - z->zone.num_cylinders; z = z->next; } seek = disk->geom->seek_constant_coeff + disk->geom->seek_linear_coeff * cyls + disk->geom->seek_sqrt_coeff * sqrt( (double) cyls ) + z->zone.track_skew * disk->geom->revolution_time / z->zone.sec_per_track; } else if( from_track != to_track ) { /* from_track and to_track must lie in the same zone. */ z = disk->geom->zbr_data; /* This while-loop finds the zone to which from_cyl belongs. */ while (from_cyl >= z->zone.num_cylinders) { from_cyl = from_cyl - z->zone.num_cylinders; z = z->next; } seek = z->zone.track_skew * disk->geom->revolution_time / z->zone.sec_per_track; } return( seek ); } static RF_TICS_t Seek(cur_time, block, disk, update) RF_TICS_t cur_time; RF_SectorNum_t block; RF_DiskState_t *disk; long update; { long cur_cyl, cur_track; /* ** current location is derived from the time, ** current track and current cylinder ** ** update current location as you go */ RF_ASSERT( block <= disk->last_block_index ); cur_cyl = disk->cur_cyl; cur_track = disk->cur_track; if (update) { disk->cur_cyl = Find_cyl( block, disk ); disk->cur_track = Find_track( block, disk ); } return( Seek_time( disk->cur_cyl, disk->cur_track, cur_cyl, cur_track, disk ) ); } static RF_TICS_t Rotate(cur_time, block, disk, update) RF_TICS_t cur_time; RF_SectorNum_t block; RF_DiskState_t *disk; long update; { /* ** current location is derived from the time, ** current track and current cylinder ** ** block the process until at the appropriate block ** updating current location as you go */ RF_ASSERT( block <= disk->last_block_index ); return( Delay_to( cur_time, block, disk ) ); } static RF_TICS_t Seek_Rotate(cur_time, block, disk, update) RF_TICS_t cur_time; RF_SectorNum_t block; RF_DiskState_t *disk; long update; { RF_TICS_t seek, delay; RF_ASSERT( block <= disk->last_block_index ); seek = Seek( cur_time, block, disk, update ); delay = seek + Rotate( cur_time+seek, block, disk, update ); return( delay ); } static RF_TICS_t GAP(sec_per_track, disk) long sec_per_track; RF_DiskState_t *disk; { RF_TICS_t tmp = (disk->geom->revolution_time/(100*sec_per_track)); return (tmp); } RF_TICS_t Block_access_time(cur_time, block, numblocks, disk, update) RF_TICS_t cur_time; RF_SectorNum_t block; RF_SectorCount_t numblocks; RF_DiskState_t *disk; long update; { RF_TICS_t delay = 0; long cur = block, end = block + numblocks; long sector, tmp; RF_ZoneList_t * z; /* ** this is the same as Seek_Rotate by merit of the mapping ** except that the access ends before the gap to the next block */ RF_ASSERT( numblocks > 0 && end-1 <= disk->last_block_index ); while( cur < end ) { sector = cur * disk->sectors_per_block; z = disk->geom->zbr_data; /* This while-loop finds the zone to which sector belongs. */ while (sector >= z->zone.num_sectors) { sector = sector - z->zone.num_sectors; z = z->next; } tmp = RF_MIN( end - cur, z->zone.sec_per_track - cur % z->zone.sec_per_track ); delay += tmp * disk->geom->revolution_time / z->zone.sec_per_track - GAP(z->zone.sec_per_track, disk); cur += tmp; if( cur != end ) delay += Seek_Rotate( cur_time+delay, cur, disk, update ); } return( delay ); } static void Zero_stats(disk) RF_DiskState_t *disk; { char traceFileName[64]; disk->stats.num_events = 0; disk->stats.seek_sum = 0; disk->stats.seekSq_sum = 0; disk->stats.rotate_sum = 0; disk->stats.rotateSq_sum = 0; disk->stats.transfer_sum = 0; disk->stats.transferSq_sum = 0; disk->stats.access_sum = 0; disk->stats.accessSq_sum = 0; disk->stats.sleep_sum=0; disk->stats.idle_sum=0; disk->stats.rw_sum=0; disk->stats.spinup_sum=0; disk->stats.last_acc=0; if (rf_diskTrace){ sprintf (traceFileName,"rf_diskTracer%dc%d\0",disk->row,disk->col); if ( (disk->traceFile= fopen(traceFileName, "w")) == NULL) { perror(traceFileName); RF_PANIC();} } } static RF_TICS_t Update_stats(cur_time, seek, rotate, transfer, disk) RF_TICS_t cur_time; RF_TICS_t seek; RF_TICS_t rotate; RF_TICS_t transfer; RF_DiskState_t *disk; { RF_TICS_t spinup=0; RF_TICS_t sleep=0; RF_TICS_t idle=0; disk->stats.num_events++; disk->stats.seek_sum += seek; disk->stats.seekSq_sum += seek*seek; disk->stats.rotate_sum += rotate; disk->stats.rotateSq_sum += rotate*rotate; disk->stats.transfer_sum += transfer; disk->stats.transferSq_sum += transfer*transfer; disk->stats.access_sum += seek+rotate+transfer; disk->stats.accessSq_sum += (seek+rotate+transfer)*(seek+rotate+transfer); /* ASSERT (cur_time - disk->stats.last_acc >= 0); */ if (cur_time-disk->stats.last_acc>disk->geom->time_to_sleep){ idle=disk->geom->time_to_sleep; sleep = cur_time - disk->stats.last_acc - idle; spinup=disk->geom->time_to_spinup; rf_globalSpinup = spinup; } else{ idle=cur_time - disk->stats.last_acc; } disk->stats.sleep_sum+=sleep; disk->stats.idle_sum+=idle; disk->stats.rw_sum+=seek+rotate+transfer; disk->stats.spinup_sum+=spinup; if (rf_diskTrace){ fprintf(disk->traceFile,"%g %g\n",disk->stats.last_acc,2.0); fprintf(disk->traceFile,"%g %g\n",(disk->stats.last_acc+idle),2.0); if (sleep){ fprintf(disk->traceFile,"%g %g\n",(disk->stats.last_acc+idle),1.0); fprintf(disk->traceFile,"%g %g\n",(disk->stats.last_acc+idle+sleep),1.0); } if (spinup){ fprintf(disk->traceFile,"%g %g\n",(cur_time),4.0); fprintf(disk->traceFile,"%g %g\n",(cur_time+spinup),4.0); } fprintf(disk->traceFile,"%g %g\n",(cur_time+spinup),3.0); fprintf(disk->traceFile,"%g %g\n",(cur_time+spinup+seek+rotate+transfer),3.0); } disk->stats.last_acc=cur_time+spinup+seek+rotate+transfer; return(spinup); } void rf_StopStats(disk, cur_time) RF_DiskState_t *disk; RF_TICS_t cur_time; { RF_TICS_t sleep=0; RF_TICS_t idle=0; if (cur_time - disk->stats.last_acc > disk->geom->time_to_sleep){ sleep = cur_time - disk->stats.last_acc-disk->geom->time_to_sleep; idle = disk->geom->time_to_sleep; } else{ idle=cur_time - disk->stats.last_acc; } disk->stats.sleep_sum+=sleep; disk->stats.idle_sum+=idle; if (rf_diskTrace){ fprintf(disk->traceFile,"%g %g\n",disk->stats.last_acc,2.0); fprintf(disk->traceFile,"%g %g\n",(disk->stats.last_acc+idle),2.0); if (sleep){ fprintf(disk->traceFile,"%g %g\n",(disk->stats.last_acc+idle),1.0); fprintf(disk->traceFile,"%g %g\n",(disk->stats.last_acc+idle+sleep),1.0); } fclose(disk->traceFile); } } /* Sometimes num_events is zero because the disk was failed at the start * of the simulation and never replaced. This causes a crash on some * architectures, which is why we have the conditional. */ void rf_Report_stats( RF_DiskState_t *disk, long *numEventsPtr, RF_TICS_t *avgSeekPtr, RF_TICS_t *avgRotatePtr, RF_TICS_t *avgTransferPtr, RF_TICS_t *avgAccessPtr, RF_TICS_t *SleepPtr, RF_TICS_t *IdlePtr, RF_TICS_t *RwPtr, RF_TICS_t *SpinupPtr) { *numEventsPtr = disk->stats.num_events; if (disk->stats.num_events) { *avgSeekPtr = disk->stats.seek_sum / disk->stats.num_events; *avgRotatePtr = disk->stats.rotate_sum / disk->stats.num_events; *avgTransferPtr = disk->stats.transfer_sum / disk->stats.num_events; *avgAccessPtr = disk->stats.access_sum / disk->stats.num_events; } else { *avgSeekPtr = 0; *avgRotatePtr = 0; *avgTransferPtr = 0; *avgAccessPtr = 0; } *SleepPtr = disk->stats.sleep_sum; *IdlePtr = disk->stats.idle_sum; *RwPtr = disk->stats.rw_sum ; *SpinupPtr = disk->stats.spinup_sum ; } int rf_Access_time( access_time, cur_time, block, numblocks, disk, media_done_time, update ) RF_TICS_t *access_time; RF_TICS_t cur_time; RF_SectorNum_t block; RF_SectorCount_t numblocks; RF_DiskState_t *disk; RF_TICS_t *media_done_time; long update; /* 1 => update disk state, 0 => don't */ { /* * first move to the start of the data, then sweep to the end */ RF_TICS_t spinup=0; RF_TICS_t seek = Seek( cur_time, block, disk, update ); RF_TICS_t rotate = Rotate( cur_time+seek, block, disk, update ); RF_TICS_t transfer = Block_access_time( cur_time+seek+rotate, block, numblocks, disk, update ); if (update) spinup=Update_stats(cur_time, seek, rotate, transfer, disk ); *media_done_time = seek+rotate+transfer; *access_time =( seek+rotate+transfer+spinup); return(0); } /* added to take into account the fact that maping code acounts for the disk label */ void rf_GeometryDoReadCapacity(disk, numBlocks, blockSize) RF_DiskState_t *disk; RF_SectorCount_t *numBlocks; int *blockSize; { *numBlocks= (disk->last_block_index + 1 )-rf_protectedSectors; *blockSize= (disk->sectors_per_block*512 ); /* in bytes */ } /* END GEOMETRY ROUTINES **********************************************/ static void rf_DiskParam(numCyls, minSeek, avgSeek, maxSeek, a, b, c) long numCyls; RF_TICS_t minSeek; RF_TICS_t avgSeek; RF_TICS_t maxSeek; RF_TICS_t *a; RF_TICS_t *b; RF_TICS_t *c; { if (minSeek == avgSeek && minSeek == maxSeek) { *a = 0.0; *b = 0.0; *c = minSeek; } else { *a = ( 15 * avgSeek - 10 * minSeek - 5 * maxSeek ) / ( 3 * sqrt( (double) numCyls )); *b = ( 7 * minSeek + 8 * maxSeek - 15 * avgSeek ) / ( 3 * numCyls ); *c = minSeek; } }