The traditional synthetic aperture radar (SAR) image quality assessment (IQA) indexes are mainly proposed based on the statistical characteristics of point and area targets. However, these indexes are not combined with the principle of SAR imaging focusing, so there are often failures. In order to overcome the shortcomings of traditional IQA indexes, based on SAR imaging principles, this paper analyzes the impact of defocusing caused by mismatched filter on imaging results, and proposes a non-reference SAR IQA index based on average blurred edge width (ABEW) in salient area. The effectiveness of this method has been validated by using SAR images of real scenes, and the results are highly consistent with the actual image quality. The novel algorithm provides a new idea and method for IQA of SAR.

Few Shot Learning is a solution to relieve the huge annotation cost in Person Re-Identification. We concentrate on one sample setting in this work, where each identity has only one labeled sample along with many unlabeled samples. Training with one sample setting, the model is easily biased towards certain identities. Moreover, a reliable pseudo-label estimation scheme can greatly improve the final performance of the model. Targeting to solve the issues above, we propose two simple and effective solutions. (a) We design the Feature Space Regularization (FSR) Loss to adjust the distribution of samples in feature space. The FSR loss make the difference in distance of all labeled samples to unlabeled samples as small as possible. (b) We propose combining the Nearest Neighbor distance with inter-class distance to estimate pseudo-label for unlabeled data, which we called Joint-Distance. Notably, the Rank-1 accuracy of our method outperforms the state of the art method by a large margin of 12.1 points (absolute, i.e., 67.9% vs. 55.8%) on Market-1501, and 10.1 points (absolute, i.e., 58.9% vs. 48.8%) on DukeMTMC-reID, respectively. We will release all the code in https://github.com/Freedomxt/Feature_Space_Regularization_for_person_Re-Identification_with_One_Sample.

As caches become larger and shared by an increasing number of cores, cache management is becoming more important. This paper explores collaborative caching, which uses software hints to influence hardware caching. Recent studies have shown that such collaboration between software and hardware can theoretically achieve optimal cache replacement on LRU-like cache.

Collaborative caching allows software to use hints to influence cache management in hardware. Previous theories have shown that such hints observe the inclusion property and can obtain optimal caching if the access sequence and the cache size are known ahead of time. Previously, the interface of a cache hint is limited, e.g., a binary choice between LRU and MRU.

In this work we first present a prioritized LRU model. For each memory access, a program specifies a priority. The loaded datum can be inserted in the middle of the cache stack between the LRU and MRU positions. It may be bypassed if the associated priority is too low. Prioritized LRU naturally organizes program accesses for all cache sizes. Alternatively, we describe a dynamic cache control scheme. Like prioritized LRU, each access is associated with a priority. The dynamic cache control compares the priority with the cache size and then chooses either the LRU or the MRU position for placing the data. As a result, a program is optimized for all instead of single cache sizes. In the discussion, we assume fully associative cache. The same idea can be applied to each set of set associative cache. Another problem is the instruction overhead now that each load and store is associated with a number. One way to reduce the cost is to use a few registers to hold the priority numbers and then include a few bits in a load or store instruction to indicate the priority register.

The goal of cache management is to maximize data reuse. Collaborative caching provides an interface for software to communicate access information to hardware. In theory, it can obtain optimal cache performance.

To achieve optimal performance, garbage-collected applications must balance the sizes of their heaps dynamically. Sizing the heap too small can reduce throughput by increasing the number of garbage collections that must be performed. Too large a heap, however, can cause the system to page and drag down the overall throughput. In today's multicore, multiprocessor machines, multiple garbage-collected applications may run simultaneously. As a result, each virtual machine (VM) must adjust its memory demands to reflect not only the behavior of the application it is running, but also the behavior of the peer applications running on the system.

This paper addresses the problem of extracting coarse-grained parallelism from large sequential code. It builds on BOP, a system for software speculative parallelization. BOP lets a user to mark possibly parallel regions (PPR) in a program and at run-time speculatively executes PPR instances using Unix processes. This short paper presents a new run-time support called continuous speculation, which fully utilizes available parallelism to tolerate differences in PPR task size and processor speed.

Good spatial locality alleviates both the latency and bandwidth problem of memory by boosting the effect of prefetching and improving the utilization of cache. However, conventional definitions of spatial locality are inadequate for a programmer to precisely quantify the quality of a program, to identify causes of poor locality, and to estimate the potential by which spatial locality can be improved. This paper describes a new, component-based model for spatial locality. It is based on measuring the change of reuse distances as a function of the data-block size. It divides spatial locality into components at program and behavior levels. While the base model is costly because it requires the tracking of the locality of every memory access, the overhead can be reduced by using small inputs and by extending a sampling-based tool. The paper presents the result of the analysis for a large set of benchmarks, the cost of the analysis, and the experience of a user study, in which the analysis helped to locate a data-layout problem and improve performance by 7 % with a 6-line change in an application with over 2,000 lines.