def ConfigureRunningEnv(num_process, size_tile_cache): """Configures the running environment. Optimal performance is obtained by increasing the number of process and a geo cache big enough to avoid swapping. Each tile covers about 100kmx100km. Swapping statistics can be obtaines using the routine: `CheckTerrainTileCacheOk()`. Args: num_process: Number of process. Special values: -1: #cpu/2 ; -2: #cpu-1 size_tile_cache: Geo cache size in number of tiles. The memory usage is about: `num_process * size_tile_cache * 60 MB` """ # Configure the global pool of processes mpool.Configure(num_process) # Configure the geo drivers to avoid swap # - for main process drive.ConfigureTerrainDriver(cache_size=size_tile_cache) drive.ConfigureNlcdDriver(cache_size=size_tile_cache) # - for worker processes mpool.RunOnEachWorkerProcess(drive.ConfigureTerrainDriver, terrain_dir=None, cache_size=size_tile_cache) mpool.RunOnEachWorkerProcess(drive.ConfigureNlcdDriver, nlcd_dir=None, cache_size=size_tile_cache) return mpool.GetNumWorkerProcesses()
# Define protection point, i.e., a tuple with named fields of # 'latitude', 'longitude' ProtectionPoint = namedtuple('ProtectionPoint', ['latitude', 'longitude']) if __name__ == '__main__': # Number of Monte Carlo iterations num_iter = 2000 # Margin check margin_db = 0.01 # Possible only because cache manager is used # Configure the global pool manager num_processes = 4 mpool.Configure(num_processes) # Note: shall not be run in child process # so protect it. # Populate protection points protection_points = [ProtectionPoint(latitude=36.9400, longitude=-75.9989), ProtectionPoint(latitude=37.7579, longitude=-75.4105), ProtectionPoint(latitude=36.1044, longitude=-73.3147), ProtectionPoint(latitude=36.1211, longitude=-75.5939)] channel = (3600, 3610) # Configure operating parameters dpa_mgr.Dpa.Configure(num_iteration=num_iter) dpa_ref = dpa_mgr.Dpa(protection_points, name='test(East1)', threshold=-144,
import os import iap import time import multiprocessing from reference_models.common import mpool from reference_models.interference import interference as interf from full_activity_dump import FullActivityDump # Number of processes for parallel execution NUM_OF_PROCESS = 30 if __name__ == '__main__': # Configure the multiprocess pool mpool.Configure(NUM_OF_PROCESS) cbsd_0 = json.load(open(os.path.join('test_data', 'cbsd_0.json'))) cbsd_1 = json.load(open(os.path.join('test_data', 'cbsd_1.json'))) cbsd_2 = json.load(open(os.path.join('test_data', 'cbsd_2.json'))) cbsd_3 = json.load(open(os.path.join('test_data', 'cbsd_3.json'))) cbsd_4 = json.load(open(os.path.join('test_data', 'cbsd_4.json'))) cbsd_5 = json.load(open(os.path.join('test_data', 'cbsd_5.json'))) cbsd_6 = json.load(open(os.path.join('test_data', 'cbsd_6.json'))) cbsd_7 = json.load(open(os.path.join('test_data', 'cbsd_7.json'))) cbsd_8 = json.load(open(os.path.join('test_data', 'cbsd_8.json'))) cbsd_9 = json.load(open(os.path.join('test_data', 'cbsd_9.json'))) cbsd_10 = json.load(open(os.path.join('test_data', 'cbsd_10.json'))) cbsd_11 = json.load(open(os.path.join('test_data', 'cbsd_11.json'))) cbsd_12 = json.load(open(os.path.join('test_data', 'cbsd_12.json'))) cbsd_13 = json.load(open(os.path.join('test_data', 'cbsd_13.json')))
def findMoveList(protection_specs, protection_points, registration_requests, grant_requests, num_iter, num_processes, pool=None): """Main routine to find CBSD indices on the move list. Inputs: protection_specs: protection specifications, an object with attributes 'lowFreq' (in Hz), 'highFreq' (in Hz), 'antHeight' (in meters), 'beamwidth' (in degrees), 'threshold' (in dBm/10MHz), 'neighbor_distances' (km), 'min_azimuth', 'max_azimuth' (degrees) where `neighbor_distances` are the neighborhood distances (km) as a sequence: [cata_dist, catb_dist, cata_oob_dist, catb_oob_dist] protection_points: a list of protection points, each one being an object providing attributes 'latitude' and 'longitude' registration_requests: a list of CBSD registration requests, each one being a dictionary containing CBSD registration information grant_requests: a list of grant requests, each one being a dictionary containing grant information; there is a one-to-one mapping between items in registration_requests and grant_requests; a CBSD with more than one grant will have corresponding duplicate items in registration_requests num_iter: number of Monte Carlo iterations num_processes: number of parallel processes to use pool: optional |multiprocessing.Pool| to use Returns: result: a Boolean list (same size as registration_requests/ grant_requests) with TRUE elements at indices having grants on the move list """ grants = data.getGrantsFromRequests(registration_requests, grant_requests) # Find the move list of each protection constraint with a pool of parallel processes. if pool is None: mpool.Configure(num_processes) pool = mpool.Pool() neighbor_distances = protection_specs.neighbor_distances try: min_azimuth = protection_specs.min_azimuth max_azimuth = protection_specs.max_azimuth except AttributeError: min_azimuth, max_azimuth = 0, 360 moveListC = partial(moveListConstraint, low_freq=protection_specs.lowFreq, high_freq=protection_specs.highFreq, grants=grants, inc_ant_height=protection_specs.antHeight, num_iter=num_iter, threshold=protection_specs.threshold, beamwidth=protection_specs.beamwidth, min_azimuth=min_azimuth, max_azimuth=max_azimuth, neighbor_distances=neighbor_distances) M_c, _ = zip(*pool.map(moveListC, protection_points)) # Find the unique CBSD indices in the M_c list of lists. M = set().union(*M_c) # Set to TRUE the elements of the output Boolean array that have grant_index in # the move list. result = np.zeros(len(grants), bool) for k, grant in enumerate(grants): if grant in M: result[k] = True output = result.tolist() return output
if __name__ == '__main__': # Process the commad line arguments. options = parser.parse_args() logging.getLogger().setLevel(_LOGGER_MAP[options.log_level.lower()]) # Configure the multiprocessing worker pool. # Your options are: # 0: single process (default if not called) # -1: use half of the cpus # -2: use all cpus (minus one) # a specific number of cpus # Or your own `pool`. logging.info('Start Worker processes') mpool.Configure(num_processes=NUM_PROCESSES) num_workers = mpool.GetNumWorkerProcesses() logging.info(' ... %d workers started' % num_workers) # Configure geo drivers logging.info('Configure geo drivers') (num_tiles_master_ned, num_tiles_worker_ned, num_tiles_master_nlcd, num_tiles_worker_nlcd) = GetGeoCacheSize(num_workers) if num_tiles_master_ned < 16: logging.warning('Required geo cache size %d (for master) is low' '- too few memory or too many workers' % num_tiles_master_ned) logging.info(' ... NED: cache size: %d per master, %d for workers' % (num_tiles_master_ned, num_tiles_worker_ned)) logging.info(' ... NLCD: cache size: %d per master, %d for workers' % (num_tiles_master_ned, num_tiles_worker_ned))
out_list = list(out_dict.items()) out_list.sort() return out_list if __name__ == '__main__': #======================================= # Decrease resolution of GWPZ/PPA for reducing time aggregate_interference.GWPZ_GRID_RES_ARCSEC = 10 aggregate_interference.PPA_GRID_RES_ARCSEC = 10 #======================================= # Configure the multiprocess pool with profiler enabled pool = profpool.PoolWithProfiler(NUM_PROCESS) mpool.Configure(pool=pool) prof0 = cProfile.Profile() #======================================= # Data directory _BASE_DATA_DIR = os.path.join(os.path.dirname(__file__), '../../interference/test_data') # Populate a list of CBSD registration requests cbsd_filename = [ 'cbsd_0.json', 'cbsd_1.json', 'cbsd_2.json', 'cbsd_3.json', 'cbsd_4.json', 'cbsd_5.json', 'cbsd_6.json', 'cbsd_7.json', 'cbsd_8.json', 'cbsd_9.json', 'cbsd_10.json', 'cbsd_11.json', 'cbsd_12.json', 'cbsd_13.json', 'cbsd_14.json', 'cbsd_15.json', 'cbsd_16.json', 'cbsd_17.json', 'cbsd_18.json', 'cbsd_19.json', 'cbsd_20.json', 'cbsd_21.json', 'cbsd_22.json', 'cbsd_23.json'
def getTileStats(): return drive.terrain_driver.stats.ActiveTilesCount() def printTileStats(): drive.terrain_driver.stats.Report() #-------------------------------------------------- # The simulation if __name__ == '__main__': # reset the random seed np.random.seed(12345) # Configure the global pool of processes mpool.Configure(num_processes) num_workers = mpool.GetNumWorkerProcesses() (all_cbsds, reg_requests, grant_requests, protection_zone, (n_a_indoor, n_a_outdoor, n_b), ax) = PrepareSimulation() # Build the grants grants = data.getGrantsFromRequests(reg_requests, grant_requests) # Build the DPA manager dpa = dpa_mgr.BuildDpa( dpa_name, 'default (%d,%d,%d,%d,%d)' % (npts_front_dpa_contour, npts_back_dpa_contour, npts_within_dpa_front, npts_within_dpa_back, front_usborder_buffer_km)) dpa.ResetFreqRange([(fmin, fmax)])