static size_t
reg_size (enum m32c_sim_reg regno)
{
switch (regno)
{
case m32c_sim_reg_r0_bank0:
case m32c_sim_reg_r1_bank0:
case m32c_sim_reg_r2_bank0:
case m32c_sim_reg_r3_bank0:
case m32c_sim_reg_r0_bank1:
case m32c_sim_reg_r1_bank1:
case m32c_sim_reg_r2_bank1:
case m32c_sim_reg_r3_bank1:
case m32c_sim_reg_flg:
case m32c_sim_reg_svf:
return 2;
case m32c_sim_reg_a0_bank0:
case m32c_sim_reg_a1_bank0:
case m32c_sim_reg_fb_bank0:
case m32c_sim_reg_sb_bank0:
case m32c_sim_reg_a0_bank1:
case m32c_sim_reg_a1_bank1:
case m32c_sim_reg_fb_bank1:
case m32c_sim_reg_sb_bank1:
case m32c_sim_reg_usp:
case m32c_sim_reg_isp:
return mask_size (addr_mask);
case m32c_sim_reg_pc:
case m32c_sim_reg_intb:
case m32c_sim_reg_svp:
case m32c_sim_reg_vct:
return mask_size (membus_mask);
case m32c_sim_reg_dmd0:
case m32c_sim_reg_dmd1:
return 1;
case m32c_sim_reg_dct0:
case m32c_sim_reg_dct1:
case m32c_sim_reg_drc0:
case m32c_sim_reg_drc1:
return 2;
case m32c_sim_reg_dma0:
case m32c_sim_reg_dma1:
case m32c_sim_reg_dsa0:
case m32c_sim_reg_dsa1:
case m32c_sim_reg_dra0:
case m32c_sim_reg_dra1:
return 3;
default:
fprintf (stderr, "m32c minisim: unrecognized register number: %d\n",
regno);
return -1;
}
}
void *cpu_map_data__alloc(struct cpu_map *map, size_t *size, u16 *type, int *max)
{
size_t size_cpus, size_mask;
bool is_dummy = cpu_map__empty(map);
/*
* Both array and mask data have variable size based
* on the number of cpus and their actual values.
* The size of the 'struct cpu_map_data' is:
*
* array = size of 'struct cpu_map_entries' +
* number of cpus * sizeof(u64)
*
* mask = size of 'struct cpu_map_mask' +
* maximum cpu bit converted to size of longs
*
* and finaly + the size of 'struct cpu_map_data'.
*/
size_cpus = cpus_size(map);
size_mask = mask_size(map, max);
if (is_dummy || (size_cpus < size_mask)) {
*size += size_cpus;
*type = PERF_CPU_MAP__CPUS;
} else {
*size += size_mask;
*type = PERF_CPU_MAP__MASK;
}
*size += sizeof(struct cpu_map_data);
return zalloc(*size);
}
void OopMapCacheEntry::deallocate_bit_mask() {
if (mask_size() > small_mask_limit && _bit_mask[0] != 0) {
assert(!Thread::current()->resource_area()->contains((void*)_bit_mask[0]),
"This bit mask should not be in the resource area");
FREE_C_HEAP_ARRAY(uintptr_t, _bit_mask[0]);
debug_only(_bit_mask[0] = 0;)
}
void OopMapCacheEntry::allocate_bit_mask() {
if (mask_size() > small_mask_limit) {
assert(_bit_mask[0] == 0, "bit mask should be new or just flushed");
_bit_mask[0] = (intptr_t)
NEW_C_HEAP_ARRAY(uintptr_t, mask_word_size());
}
}
InterpreterOopMap::~InterpreterOopMap() {
// The expection is that the bit mask was allocated
// last in this resource area. That would make the free of the
// bit_mask effective (see how FREE_RESOURCE_ARRAY does a free).
// If it was not allocated last, there is not a correctness problem
// but the space for the bit_mask is not freed.
assert(_resource_allocate_bit_mask, "Trying to free C heap space");
if (mask_size() > small_mask_limit) {
FREE_RESOURCE_ARRAY(uintptr_t, _bit_mask[0], mask_word_size());
}
}
DriftingGratingStimulus::DriftingGratingStimulus(const ParameterValueMap ¶meters) :
StandardDynamicStimulus(parameters),
xoffset(registerVariable(parameters[BasicTransformStimulus::X_POSITION])),
yoffset(registerVariable(parameters[BasicTransformStimulus::Y_POSITION])),
width(registerVariable(parameters[BasicTransformStimulus::X_SIZE])),
height(registerVariable(parameters[BasicTransformStimulus::Y_SIZE])),
rotation(registerVariable(parameters[BasicTransformStimulus::ROTATION])),
alpha_multiplier(registerVariable(parameters[BasicTransformStimulus::ALPHA_MULTIPLIER])),
spatial_frequency(registerVariable(parameters[FREQUENCY])),
speed(registerVariable(parameters[SPEED])),
starting_phase(registerVariable(parameters[STARTING_PHASE])),
direction_in_degrees(registerVariable(parameters[DIRECTION]))
{
const std::string &grating_type = parameters[GRATING_TYPE].str();
shared_ptr<Variable> grating_sample_rate(parameters[GRATING_SAMPLE_RATE]);
if (grating_type == "sinusoid") {
grating = shared_ptr<SinusoidGratingData>(new SinusoidGratingData(grating_sample_rate));
} else if (grating_type == "square") {
grating = shared_ptr<SquareGratingData>(new SquareGratingData(grating_sample_rate));
} else if (grating_type == "triangle") {
grating = shared_ptr<TriangleGratingData>(new TriangleGratingData(grating_sample_rate));
} else if (grating_type == "sawtooth") {
grating = shared_ptr<SawtoothGratingData>(new SawtoothGratingData(grating_sample_rate, parameters[INVERTED]));
} else {
throw SimpleException("illegal grating type", grating_type);
}
const std::string &mask_type = parameters[MASK].str();
shared_ptr<Variable> mask_size(new ConstantVariable(128L));
if (mask_type == "rectangle") {
mask = shared_ptr<Mask>(new RectangleMask(mask_size));
} else if (mask_type == "ellipse") {
mask = shared_ptr<Mask>(new EllipseMask(mask_size));
} else if (mask_type == "gaussian") {
mask = shared_ptr<Mask>(new GaussianMask(mask_size, parameters[MEAN], parameters[STD_DEV]));
} else {
throw SimpleException("illegal mask", mask_type);
}
}
if (old_dtype != dtype || old_wsize != wsize) {
printf("Changing '%s' to data type %s, word size %d (msb at %d)\n",
sval, dtype == DATA_UNSIGNED ? "unsigned" : "int", wsize, msone);
}
#endif
ok = 1;
}
}
if (!ok) {
yyserror("Number too large for data type: '%s'", sval);
}
}
}
result->wsize = wsize;
result->val = dtype == DATA_FLOAT ? float_const(fval) :
mask_size(dtype == DATA_UNSIGNED ? uint_const(val) : int_const(val), wsize, dtype);
result->dtype = dtype;
return result;
}
/******************************************** Output Display *****************************************/
/* 100 spaces */
static char *fill_buf =
" ";
static int fill_pos = 0;
static int max_pos = 99;
static char *fill_string = "";
void reset_pos() {
fill_pos = max_pos;
void on_start_thread(std::size_t num_thread)
{
if (nullptr == queues_[num_thread])
{
queues_[num_thread] =
new thread_queue_type(max_queue_thread_count_);
if (num_thread < high_priority_queues_.size())
{
high_priority_queues_[num_thread] =
new thread_queue_type(max_queue_thread_count_);
}
}
// forward this call to all queues etc.
if (num_thread < high_priority_queues_.size())
high_priority_queues_[num_thread]->on_start_thread(num_thread);
if (num_thread == queues_.size()-1)
low_priority_queue_.on_start_thread(num_thread);
queues_[num_thread]->on_start_thread(num_thread);
std::size_t num_threads = queues_.size();
// get numa domain masks of all queues...
std::vector<mask_type> numa_masks(num_threads);
std::vector<mask_type> core_masks(num_threads);
for (std::size_t i = 0; i != num_threads; ++i)
{
std::size_t num_pu = get_pu_num(i);
numa_masks[i] =
topology_.get_numa_node_affinity_mask(num_pu, numa_sensitive_ != 0);
core_masks[i] =
topology_.get_core_affinity_mask(num_pu, numa_sensitive_ != 0);
}
// iterate over the number of threads again to determine where to
// steal from
std::ptrdiff_t radius =
static_cast<std::ptrdiff_t>((num_threads / 2.0) + 0.5);
victim_threads_[num_thread].reserve(num_threads);
std::size_t num_pu = get_pu_num(num_thread);
mask_cref_type pu_mask =
topology_.get_thread_affinity_mask(num_pu, numa_sensitive_ != 0);
mask_cref_type numa_mask = numa_masks[num_thread];
mask_cref_type core_mask = core_masks[num_thread];
// we allow the thread on the boundary of the NUMA domain to steal
mask_type first_mask = mask_type();
resize(first_mask, mask_size(pu_mask));
std::size_t first = find_first(numa_mask);
if (first != std::size_t(-1))
set(first_mask, first);
else
first_mask = pu_mask;
auto iterate = [&](hpx::util::function_nonser<bool(std::size_t)> f)
{
// check our neighbors in a radial fashion (left and right
// alternating, increasing distance each iteration)
int i = 1;
for (/**/; i < radius; ++i)
{
std::ptrdiff_t left =
(static_cast<std::ptrdiff_t>(num_thread) - i) %
static_cast<std::ptrdiff_t>(num_threads);
if (left < 0)
left = num_threads + left;
if (f(std::size_t(left)))
{
victim_threads_[num_thread].push_back(
static_cast<std::size_t>(left));
}
std::size_t right = (num_thread + i) % num_threads;
if (f(right))
{
victim_threads_[num_thread].push_back(right);
}
}
if ((num_threads % 2) == 0)
{
std::size_t right = (num_thread + i) % num_threads;
if (f(right))
{
victim_threads_[num_thread].push_back(right);
}
}
};
// check for threads which share the same core...
iterate(
[&](std::size_t other_num_thread)
{
return any(core_mask & core_masks[other_num_thread]);
}
);
// check for threads which share the same numa domain...
iterate(
[&](std::size_t other_num_thread)
{
return
!any(core_mask & core_masks[other_num_thread])
&& any(numa_mask & numa_masks[other_num_thread]);
}
);
// check for the rest and if we are numa aware
if (numa_sensitive_ != 2 && any(first_mask & pu_mask))
{
iterate(
[&](std::size_t other_num_thread)
{
return !any(numa_mask & numa_masks[other_num_thread]);
}
);
}
}
template <typename MatElem> cv::Mat _generateGaussianMask(const cv::Mat& covariance, double ignore_rate){
assert(skl::checkMat(covariance,-1,1,cv::Size(2,2)));
cv::Mat Wvec,U,Vt;
cv::SVD svd;
svd.compute(covariance,Wvec,U,Vt);
cv::Mat W(covariance.size(),covariance.type());
std::vector<MatElem> std_dev(W.rows);
for(int i=0;i<W.rows;i++){
std_dev[i] = (MatElem)std::sqrt((double)Wvec.at<MatElem>(i,0));
}
// mask size must be odd num
cv::Point center(
static_cast<int>(std_dev[0] * ignore_rate/2),
static_cast<int>(std_dev[1] * ignore_rate/2));
cv::Size mask_size(
center.x*2+1,
center.y*2+1);
cv::Mat gaussian_x = cv::getGaussianKernel(mask_size.width ,-1, covariance.depth());
cv::Mat gaussian_y = cv::getGaussianKernel(mask_size.height,-1, covariance.depth());
cv::Mat gaussian_mask = gaussian_y * gaussian_x.t();
/* for(int i=0;i<Wvec.rows;i++){
W.at<MatElem>(i,i) = Wvec.at<MatElem>(i,0);
}
std::cout << "covariance >> " << covariance << std::endl;
std::cout << "W >> " << W << std::endl;
std::cout << "U >> " << U << std::endl;
std::cout << "Vt >> " << Vt << std::endl;
std::cout << (U*W*Vt) << std::endl;
*/
float rad = skl::radian(cv::Point2f(U.at<MatElem>(0,0),U.at<MatElem>(0,1)));
float degree = rad*180/CV_PI;
// std::cout << "gausiann rotation: " << degree << std::endl;
/*
// DEBUG CODE: draw vertical/horizontal lines crossing at the center.
for(int x=0;x<gaussian_mask.cols;x++){
gaussian_mask.at<MatElem>(center.y,x) = 1;
}
for(int y=0;y<gaussian_mask.rows;y++){
gaussian_mask.at<MatElem>(y,center.x) = 1;
}
*/
// rotate gaussian mask
int max_length = std::max(mask_size.width,mask_size.height);
cv::Size dist_size(max_length,max_length);
cv::Mat gaussian_mask_max_length(dist_size,gaussian_mask.type(),cv::Scalar(0));
int diff_x = max_length - mask_size.width;
int diff_y = max_length - mask_size.height;
gaussian_mask.copyTo(
cv::Mat(
gaussian_mask_max_length,
cv::Rect(diff_x/2,diff_y/2,mask_size.width,mask_size.height)
)
);
cv::Mat affin_mat = cv::getRotationMatrix2D(cv::Point(max_length/2,max_length/2),degree,1.0);
// std::cout << affin_mat << std::endl;
cv::Mat gaussian_mask_rotated;
/*
cv::namedWindow("before rotation",0);
cv::imshow("before rotation",gaussian_mask_max_length);
*/
cv::warpAffine(gaussian_mask_max_length,gaussian_mask_rotated,affin_mat,dist_size);
return gaussian_mask_rotated;
}
