/* __ompc_init_task_pool_simple:
* Initializes a task pool, for which tasks may be added and taken. The task
* pool will be single-level, with 1 task queue allotted per thread.
*/
omp_task_pool_t * __ompc_create_task_pool_simple(int team_size)
{
int i;
omp_task_pool_t *new_pool;
omp_task_queue_level_t *per_thread;
new_pool = (omp_task_pool_t *) aligned_malloc(sizeof(omp_task_pool_t),
CACHE_LINE_SIZE);
Is_True(new_pool != NULL, ("__ompc_create_task_pool: couldn't malloc new_pool"));
new_pool->team_size = team_size;
new_pool->num_levels = 1;
new_pool->num_pending_tasks = 0;
new_pool->level = aligned_malloc(sizeof(omp_task_queue_level_t),
CACHE_LINE_SIZE);
pthread_mutex_init(&(new_pool->pool_lock), NULL);
pthread_cond_init(&(new_pool->pool_cond), NULL);
Is_True(new_pool->level != NULL,
("__ompc_create_task_pool: couldn't malloc level"));
per_thread = &new_pool->level[PER_THREAD];
per_thread->num_queues = team_size;
per_thread->task_queue = aligned_malloc(sizeof(omp_queue_t) * team_size,
CACHE_LINE_SIZE);
Is_True(per_thread->task_queue != NULL,
("__ompc_create_task_pool: couldn't malloc per-thread task queue"));
for (i = 0; i < team_size; i++)
__ompc_queue_init(&per_thread->task_queue[i], __omp_task_queue_num_slots);
return new_pool;
}
int main(void)
{
void * p = malloc(103);
void * q = malloc(1000);
void * r = malloc(7);
void * x = aligned_malloc(8, 100);
void * y = aligned_malloc(32, 1035);
void * z = aligned_malloc(4, 8);
printf("Raw malloc pointers, no alignment enforced:\n");
printf("\t%p, %p, %p\n", p, q, r);
printf("\tNote: you may see 4-8 byte alignment on host PC\n");
printf("aligned to 8: %p\n", x);
printf("aligned to 32: %p\n", y);
printf("aligned to 4: %p\n", z);
aligned_free(x), x = NULL;
aligned_free(y), y = NULL;
aligned_free(z), z = NULL;
free(p), p = NULL;
free(q), q = NULL;
free(r), r = NULL;
return 0;
}
void init_sliders()
{
int i;
bitboard_t x,occ;
for(i = 0; i < 64; i++)
{//initializing the square hashtable pointers:
b_moves[i] = (bitboard_t *)aligned_malloc((size_t)(1 << b_bits[i]) * sizeof(bitboard_t),64);
r_moves[i] = (bitboard_t *)aligned_malloc((size_t)(1 << r_bits[i]) * sizeof(bitboard_t),64);
//for each square:
// - get each possible occupancy state according the mask of relevant squares
// - get the attack config. against each occupancy state
// - hashing by the multiplication method to retrieve index:
// the currently generated occupancy state * magic number >> relevant mask bits count:
// (Pradyumna Kannan's reduced array access approach.)
// - store the attack configuration at position [index] in the hashtable.
for(x = 0ULL; x < (1ULL << b_bits[i]); x++)
{ occ = get_blockers(x, b_mask[i]);
b_moves[i][(occ * b_magics[i]) >> b_shift[i]]= get_bishop_atk(i, occ);
}
for(x = 0ULL; x < (1ULL << r_bits[i]); x++)
{ occ = get_blockers(x, r_mask[i]);
r_moves[i][(occ * r_magics[i]) >> r_shift[i]] = get_rook_atk(i, occ);
}
}
}
int *pqsort(int* input, int num_elements, int num_threads)
{
if(num_threads*num_threads*CACHE_LINE_SIZE > num_elements){
num_threads = (int)(sqrt(num_elements/CACHE_LINE_SIZE));
}
int power_of=1;
while(power_of < num_threads){
power_of *= 2;
}
num_threads = power_of;
if(num_threads == 1){
qsort(input , num_elements, sizeof(int), compare);
return input;
}
// YOUR CODE GOES HERE
long i;
sort_data *sort_data_array = (sort_data*)malloc(num_threads*sizeof(sort_data));
pthread_t *thread_id = (pthread_t*)malloc(num_threads*sizeof(pthread_t));
all_pivot_data = (pivot_data*)aligned_malloc(num_threads*sizeof(pivot_data));
//all_pivot_data = (pivot_data*)malloc(num_threads*sizeof(pivot_data));
/* MAX_THREADS = 1;
while( MAX_THREADS < num_threads ){
MAX_THREADS = MAX_THREADS << 1;
}
printf("MAX_THREADS %d\n", MAX_THREADS);*/
//barr = (barrier_node*)malloc(MAX_THREADS*sizeof(barrier_node));
//barr = (barrier_node*)aligned_malloc(num_threads*sizeof(barrier_node));
barr = (barrier_node*)malloc(num_threads*sizeof(barrier_node));
ps = (prefix_sum_node*)aligned_malloc(num_threads*sizeof(prefix_sum_node));
mylib_init_prefix_sum(ps, num_threads, all_lengths);
final_pivots = (int*)malloc((num_threads-1)*sizeof(int));
partitions = (partition_data*)aligned_malloc(num_threads*sizeof(partition_data));
for(i=0; i<num_threads; i++){
partitions[i].id = i;
}
mylib_init_barrier (barr, num_threads);
output = (int*)aligned_malloc(num_elements*sizeof(int));
// Divide input into num_threads chunks
divide(input, num_elements, num_threads, sort_data_array);
// create threads for locally sorting the partitions
for(i=0; i<num_threads; i++){
pthread_create(&thread_id[i], NULL, run_threads, sort_data_array+i);
//printf("i %ld\n", thread_id[i]);
}
for(i=0; i<num_threads; i++){
pthread_join(thread_id[i], NULL);
}
return output; //return appropriately
}
int main(int argc, char **argv) {
char **endptr;
int alignment = atoi(argv[1]);
int *p = (int *)aligned_malloc(100, alignment);
int *q = (int *)aligned_malloc(128, alignment);
int *r = (int *)aligned_malloc(128, alignment);
printf("%s: %p\n", argv[1], p);
aligned_free(p);
aligned_free(q);
aligned_free(r);
return 0;
}
ssize_t write_blockwise(int fd, void *orig_buf, size_t count)
{
void *hangover_buf, *hangover_buf_base = NULL;
void *buf, *buf_base = NULL;
int r, hangover, solid, bsize, alignment;
ssize_t ret = -1;
if ((bsize = sector_size(fd)) < 0)
return bsize;
hangover = count % bsize;
solid = count - hangover;
alignment = get_alignment(fd);
if ((long)orig_buf & (alignment - 1)) {
buf = aligned_malloc(&buf_base, count, alignment);
if (!buf)
goto out;
memcpy(buf, orig_buf, count);
} else
buf = orig_buf;
r = write(fd, buf, solid);
if (r < 0 || r != solid)
goto out;
if (hangover) {
hangover_buf = aligned_malloc(&hangover_buf_base, bsize, alignment);
if (!hangover_buf)
goto out;
r = read(fd, hangover_buf, bsize);
if (r < 0 || r != bsize)
goto out;
r = lseek(fd, -bsize, SEEK_CUR);
if (r < 0)
goto out;
memcpy(hangover_buf, (char*)buf + solid, hangover);
r = write(fd, hangover_buf, bsize);
if (r < 0 || r != bsize)
goto out;
}
ret = count;
out:
free(hangover_buf_base);
if (buf != orig_buf)
free(buf_base);
return ret;
}
void TimgFilterNoiseMplayer::Tprocess::init(int strength,const TnoiseSettings *Icfg)
{
cfg=*Icfg;
noise=(int8_t*)aligned_malloc(MAX_NOISE*sizeof(int8_t));
int i,j;
for (i=0,j=0; i<MAX_NOISE; i++,j++) {
if(cfg.uniform)
if (cfg.averaged)
if (cfg.pattern) {
noise[i]=int8_t((RAND_N(strength)-strength/2)/6+TimgFilterNoise::patt[j%4]*strength*0.25/3);
} else {
noise[i]=int8_t((RAND_N(strength)-strength/2)/3);
}
else if (cfg.pattern) {
noise[i]=int8_t((RAND_N(strength)-strength/2)/2+TimgFilterNoise::patt[j%4]*strength*0.25);
} else {
noise[i]=int8_t(RAND_N(strength)-strength/2);
}
else {
double x1, x2, w, y1;
do {
x1=2.0*rand()/(float)RAND_MAX-1.0;
x2=2.0*rand()/(float)RAND_MAX-1.0;
w=x1*x1+x2*x2;
} while (w>=1.0);
w=sqrt((-2.0*log(w))/w);
y1=x1*w;
y1*=strength/sqrt(3.0);
if (cfg.pattern) {
y1/=2;
y1+=TimgFilterNoise::patt[j%4]*strength*0.35;
}
if (y1<-128) {
y1=-128;
} else if (y1> 127) {
y1= 127;
}
if (cfg.averaged) {
y1/=3.0;
}
noise[i]=(int8_t)y1;
}
if (RAND_N(6)==0) {
j--;
}
}
for (i=0; i<MAX_RES; i++)
for (j=0; j<3; j++) {
prev_shift[i][j]=noise+(rand()&(MAX_SHIFT-1));
}
if (nonTempRandShift[0]==-1)
for (i=0; i<MAX_RES; i++) {
nonTempRandShift[i]=rand()&(MAX_SHIFT-1);
}
shiftptr=0;
}
int start()
{
error_ptr = no_error;
error_len = sizeof(no_error) - 1;
config_init();
jparse_init();
id = (unsigned char *)aligned_malloc(32, SHRT_MAX * 8);
if (id == NULL) {
api_log_printf("[AK306] Unable to allocate id buffer\r\n");
error_ptr = err_unable_to_allocate_id_buffer;
error_len = sizeof(err_unable_to_allocate_id_buffer) - 1;
return -1;
}
api_db_enum_objects(enum_callback, NULL);
api_listen_udp(api_tag, host.c_str(), dport.c_str(), data);
api_listen_udp(api_tag, host.c_str(), uport.c_str(), update);
now = time(NULL);
api_log_printf("[AK306] Started\r\n");
return 0;
}
/* __ompc_list_add_slots
* q: the queue to add slots to
* num_slots: number of additional slots to allocate for queue
* (not contiguous)
*/
static inline void
__ompc_list_add_slots(omp_queue_t *q, int num_slots)
{
omp_queue_slot_t *new_slots, *tail, *head;
unsigned int tail_index, head_index;
int old_num_slots = q->num_slots;
tail = q->tail;
head = q->head;
new_slots = aligned_malloc( sizeof(omp_queue_slot_t) * num_slots,
CACHE_LINE_SIZE);
Is_True(new_slots != NULL, ("couldn't resize the queue"));
/* think about if we can avoid this initialization */
memset(new_slots, 0, num_slots*sizeof(omp_queue_slot_t));
/* link in the newly allocated slots */
if (tail->next)
tail->next->prev = NULL;
if (head->prev)
head->prev->next = NULL;
tail->next = new_slots;
new_slots[0].prev = tail;
head->prev = &new_slots[num_slots-1];
new_slots[num_slots-1].next = head;
q->num_slots = old_num_slots + num_slots;
}
/**
* gst_buffer_new_and_alloc:
* @size: the size of the new buffer's data.
*
* Creates a newly allocated buffer with data of the given size.
* The buffer memory is not cleared. If the requested amount of
* memory can't be allocated, the program will abort. Use
* gst_buffer_try_new_and_alloc() if you want to handle this case
* gracefully or have gotten the size to allocate from an untrusted
* source such as a media stream.
*
*
* Note that when @size == 0, the buffer data pointer will be NULL.
*
* MT safe.
* Returns: the new #GstBuffer.
*/
GstBuffer *
gst_buffer_new_and_alloc (guint size)
{
GstBuffer *newbuf;
newbuf = gst_buffer_new ();
#ifdef HAVE_POSIX_MEMALIGN
{
gpointer memptr = NULL;
if (G_LIKELY (size)) {
if (G_UNLIKELY (!aligned_malloc (&memptr, size))) {
/* terminate on error like g_memdup() would */
g_error ("%s: failed to allocate %u bytes", G_STRLOC, size);
}
}
newbuf->malloc_data = (guint8 *) memptr;
GST_BUFFER_FREE_FUNC (newbuf) = free;
}
#else
newbuf->malloc_data = g_malloc (size);
#endif
GST_BUFFER_DATA (newbuf) = newbuf->malloc_data;
GST_BUFFER_SIZE (newbuf) = size;
GST_CAT_LOG (GST_CAT_BUFFER, "new %p of size %d", newbuf, size);
return newbuf;
}
dsp_linknode * new_dsp(int *ierr)
{
int i=0;
*ierr=-1;
dsp_linknode * sp_l=(dsp_linknode *)aligned_malloc(sizeof(dsp_linknode));
sp_l->number=DSP_MATRIX;
sp_l->contents.A=NULL;
sp_l->contents.IA1=NULL;
sp_l->contents.IA2=NULL;
sp_l->contents.PB=NULL;
sp_l->contents.PE=NULL;
sp_l->contents.BP1=NULL;
sp_l->contents.BP2=NULL;
sp_l->contents.FIDA=NULL_FORMAT;
for(i=0;i<11;i++)
sp_l->contents.DESCRA[i]='0';
for(i=0;i<10;i++)
sp_l->contents.INFOA[i]='0';
sp_l->pntr=NULL;
*ierr=0;
return sp_l;
}
bool check_constant(int size, uint8_t w) {
uint64_t * prec = aligned_malloc(64, size * sizeof(uint64_t));
memset(prec,w,size * sizeof(uint64_t));
bool answer = check(prec,size);
free(prec);
return answer;
}
/* __ompc_init_task_pool_simple_2level:
* Initializes a task pool, for which tasks may be added and taken.
*/
omp_task_pool_t * __ompc_create_task_pool_simple_2level(int team_size)
{
int i;
omp_task_pool_t *new_pool;
omp_task_queue_level_t *per_thread;
omp_task_queue_level_t *community;
new_pool = (omp_task_pool_t *) aligned_malloc(sizeof(omp_task_pool_t),
CACHE_LINE_SIZE);
Is_True(new_pool != NULL, ("__ompc_create_task_pool: couldn't malloc new_pool"));
new_pool->team_size = team_size;
new_pool->num_levels = 2;
new_pool->num_pending_tasks = 0;
new_pool->level = aligned_malloc(sizeof(omp_task_queue_level_t)*2,
CACHE_LINE_SIZE);
pthread_mutex_init(&(new_pool->pool_lock), NULL);
pthread_cond_init(&(new_pool->pool_cond), NULL);
Is_True(new_pool->level != NULL,
("__ompc_create_task_pool: couldn't malloc level"));
per_thread = &new_pool->level[PER_THREAD];
community = &new_pool->level[COMMUNITY];
per_thread->num_queues = team_size;
per_thread->task_queue = aligned_malloc(sizeof(omp_queue_t) * team_size,
CACHE_LINE_SIZE);
community->num_queues = 1;
community->task_queue = aligned_malloc(sizeof(omp_queue_t), CACHE_LINE_SIZE);
Is_True(per_thread->task_queue != NULL,
("__ompc_create_task_pool: couldn't malloc per-thread task queues"));
Is_True(community->task_queue != NULL,
("__ompc_create_task_pool: couldn't malloc community task queue"));
for (i = 0; i < team_size; i++)
__ompc_queue_init(&per_thread->task_queue[i], __omp_task_queue_num_slots);
/* what's a good size for the community queue, as a function of the local queue
* sizes and the team size? Just going to make it 2 * local queue size for
* now.
*/
__ompc_queue_init(community->task_queue, __omp_task_queue_num_slots*2);
return new_pool;
}
void TimgFilterLogoaway::Tplane::renderShapeUwe(const TlogoawaySettings *cfg)
{
if (!uwetable) {
uwetable=(double*)aligned_malloc(w*h*sizeof(double));
uweweightsum=(double*)aligned_malloc(w*h*sizeof(double));
calcUweWeightTable(w,h,cfg->blur);
}
int radius=3*(cfg->vhweight+1);
const unsigned char *modeparambitmap=parambitmapdata+parambitmapstride;
for (int y=1; y<h-1; y++,modeparambitmap+=parambitmapstride)
for (int x=1; x<w-1; x++)
if(modeparambitmap[x]>SHAPEMAP_NOCHANGE &&
modeparambitmap[x]<SHAPEMAP_CONTOUR) {
int lb=x-radius;
int rb=x+radius;
int ub=y-radius;
int db=y+radius;
if (lb<0) {
lb=0;
}
if (rb>w-1) {
lb=w-1;
}
if (ub<0) {
ub=0;
}
if (db>h-1) {
db=h-1;
}
double weightsum=0.0;
double b=0.0;
for (int sy=ub; sy<=db; sy++)
for (int sx=lb; sx<=rb; sx++)
if (parambitmapdata[sy*parambitmapstride+sx]>=SHAPEMAP_CONTOUR) {
double weight = uwetable[abs(y-sy)*w+abs(x-sx)];
b+=logotempdata[sy*logotempstride+sx]*w;
weightsum+=weight;
}
int bi = (int) (b/weightsum);
logotempdata[y*logotempstride+x]=(unsigned char)bi;
}
}
int pnt_init()
{ aligned_free((void *)pnt);
pnt = 0;
pnt = (pawn_entry_t *)aligned_malloc((size_t)PNTSIZE*sizeof(pawn_entry_t), PT_ALIGNMENT);
if(!pnt) return false;
aligned_wipe_out((void *)pnt, (size_t)PNTSIZE*sizeof(pawn_entry_t), PT_ALIGNMENT);
return true;
}
/*!
@brief Allocator based allocation of aligned memory
Allocate a buffer of bytes aligned on an arbitrary alignment using
a custom allocator.
@param alloc The \c Allocator to use for performing allocation
@param nbytes Number of bytes to allocate.
@param align Alignment boundary to follow
@return A pointer to an aligned memory block of @c nbytes bytes. If the
allocation fails, it returns a null pointer. For optimization
purpose, this pointer is marked as properly aligned by using
compiler specific attributes.
**/
template<class Allocator> BOOST_FORCEINLINE
typename boost::dispatch::meta
::enable_if_type<typename Allocator::pointer, void*>::type
allocate( Allocator& alloc, std::size_t nbytes, std::size_t align )
{
return aligned_malloc ( nbytes, align
, details::allocator_malloc<Allocator>(alloc)
);
}
bool check_step(int size, int step) {
uint64_t * prec = aligned_malloc(64, size * sizeof(uint64_t));
memset(prec,0,size * sizeof(uint64_t));
for(int i = 0; i < size * (int) sizeof(uint64_t); i+= step) {
prec[i/64] |= (UINT64_C(1)<<(i%64));
}
bool answer = check(prec,size);
free(prec);
return answer;
}
bool check_continuous(int size, int runstart, int runend) {
uint64_t * prec = aligned_malloc(64, size * sizeof(uint64_t));
memset(prec,0,size * sizeof(uint64_t));
for(int i = runstart; i < runend; ++i) {
prec[i/64] |= (UINT64_C(1)<<(i%64));
}
bool answer = check(prec,size);
free(prec);
return answer;
}
void initialize_inventory(Inventory* inv, int cap) {
inv->locked = SDL_CreateMutex();
inv->capacity = cap;
size_t items_size = sizeof(ItemCommon) * cap;
inv->items = aligned_malloc(items_size);
SDL_memset(inv->items, 0, items_size);
for (int i = 0; i < cap; i++) {
inv->items[i].item_type_id = ITEM_NONE;
}
}
void Prng::init_chacha_png(uint8_t *key, uint8_t *iv) {
chacha = (ECRYPT_ctx*)aligned_malloc(sizeof(ECRYPT_ctx));
random_state = new u8[RANDOM_STATE_SIZE];
ECRYPT_keysetup(chacha, key, 256, 64);
ECRYPT_ivsetup(chacha, iv);
chacha_refill_randomness();
return;
}
/* Create random image for testing purposes */
static pixman_image_t *
create_random_image (pixman_format_code_t *allowed_formats,
int max_width,
int max_height,
int max_extra_stride,
pixman_format_code_t *used_fmt)
{
int n = 0, i, width, height, stride;
pixman_format_code_t fmt;
uint32_t *buf;
pixman_image_t *img;
while (allowed_formats[n] != PIXMAN_null)
n++;
if (n > N_MOST_LIKELY_FORMATS && lcg_rand_n (4) != 0)
n = N_MOST_LIKELY_FORMATS;
fmt = allowed_formats[lcg_rand_n (n)];
width = lcg_rand_n (max_width) + 1;
height = lcg_rand_n (max_height) + 1;
stride = (width * PIXMAN_FORMAT_BPP (fmt) + 7) / 8 +
lcg_rand_n (max_extra_stride + 1);
stride = (stride + 3) & ~3;
/* do the allocation */
buf = aligned_malloc (64, stride * height);
/* initialize image with random data */
for (i = 0; i < stride * height; i++)
{
/* generation is biased to having more 0 or 255 bytes as
* they are more likely to be special-cased in code
*/
*((uint8_t *)buf + i) = lcg_rand_n (4) ? lcg_rand_n (256) :
(lcg_rand_n (2) ? 0 : 255);
}
img = pixman_image_create_bits (fmt, width, height, buf, stride);
if (PIXMAN_FORMAT_TYPE (fmt) == PIXMAN_TYPE_COLOR)
{
pixman_image_set_indexed (img, &(rgb_palette[PIXMAN_FORMAT_BPP (fmt)]));
}
else if (PIXMAN_FORMAT_TYPE (fmt) == PIXMAN_TYPE_GRAY)
{
pixman_image_set_indexed (img, &(y_palette[PIXMAN_FORMAT_BPP (fmt)]));
}
image_endian_swap (img);
if (used_fmt) *used_fmt = fmt;
return img;
}
void convert_into_pivot_data(int num_threads, int thread_id, int my_length){
int* myptr = output + ps[thread_id].sum;
pivot_data* pd = (pivot_data*)aligned_malloc(num_threads * sizeof(pivot_data));
int i;
for(i=0; i<num_threads; i++){
pd[i].length = partitions[i].length[thread_id];
pd[i].pivots = partitions[i].data[thread_id];
pd[i].ctr = 0;
}
merge(num_threads, my_length, pd, myptr);
}
int main(int argc, const char **argv) {
while(true) {
switch (rpc_call) {
case Message::None:
break;
case Message::Alloc:
set_rpc_return(reinterpret_cast<int>(aligned_malloc(hvx_alignment, RPC_ARG(0))));
break;
case Message::Free:
aligned_free(reinterpret_cast<void*>(RPC_ARG(0)));
set_rpc_return(0);
break;
case Message::InitKernels:
set_rpc_return(initialize_kernels(
reinterpret_cast<unsigned char*>(RPC_ARG(0)),
RPC_ARG(1),
RPC_ARG(2),
reinterpret_cast<handle_t*>(RPC_ARG(3))));
break;
case Message::GetSymbol:
set_rpc_return(get_symbol(
static_cast<handle_t>(RPC_ARG(0)),
reinterpret_cast<const char *>(RPC_ARG(1)),
RPC_ARG(2),
RPC_ARG(3)));
break;
case Message::Run:
set_rpc_return(run(
static_cast<handle_t>(RPC_ARG(0)),
static_cast<handle_t>(RPC_ARG(1)),
reinterpret_cast<const buffer*>(RPC_ARG(2)),
RPC_ARG(3),
reinterpret_cast<buffer*>(RPC_ARG(4)),
RPC_ARG(5),
reinterpret_cast<const buffer*>(RPC_ARG(6)),
RPC_ARG(7)));
break;
case Message::ReleaseKernels:
set_rpc_return(release_kernels(
static_cast<handle_t>(RPC_ARG(0)),
RPC_ARG(1)));
break;
case Message::Break:
return 0;
default:
log_printf("Unknown message: %d\n", rpc_call);
return -1;
}
}
log_printf("Unreachable!\n");
return 0;
}
main()
{
/* malloc adds a header before the pointer it returns to use in free
This header must not be modified and the original pointer must be
retrievable. So let's take a cue from malloc's book and add a
header of our own. This header is only 1 sizeof(void*) long and will
store the original address for use in aligned_free. It will be
located 1 sizeof(void*) before the pointer we return. This should
operate correctly regardless of the width of the memory address. */
test = aligned_malloc(malloc_size, malloc_alignment);
aligned_free(test);
}
inline aligned_stack_buffer<T, A>::aligned_stack_buffer(size_type n)
: m_size(n)
{
#ifdef XSIMD_ALLOCA
if (sizeof(T) * n <= XSIMD_STACK_ALLOCATION_LIMIT)
{
m_ptr = reinterpret_cast<pointer>(
(reinterpret_cast<size_t>(XSIMD_ALLOCA(n + A)) &
~(size_t(A - 1))) +
A);
m_heap_allocation = false;
}
else
{
m_ptr = reinterpret_cast<pointer>(aligned_malloc(n, A));
m_heap_allocation = true;
}
#else
m_ptr = reinterpret_cast<pointer>(aligned_malloc(n, A));
m_heap_allocation = true;
#endif
}
int main()
{
int bytes_required , alignment ;
printf("\nEnter the bytes_required and alignment :");
scanf("%d %d",&bytes_required , &alignment);
int *ptr = aligned_malloc(bytes_required,alignment);
printf("\nAddress: %d\n",ptr);
return 0;
}
void partition(sort_data* sort_this){
int num_threads = sort_this->num_threads;
int** data = (int**)aligned_malloc(num_threads*sizeof(int*));
int* length = (int*)aligned_malloc(num_threads*sizeof(int));
int i, search;
int elements = sort_this->length;
data[0] = sort_this->sortMe;
for(i=1; i<num_threads; i++){
//printf("thread# %d elements %d final_pivots %d\n", sort_this->thread_id, elements, final_pivots[i-1]);
length[i-1] = binary(elements, data[i-1], final_pivots[i-1]);
data[i] = data[i-1] + length[i-1];
elements -= length[i-1];
//printf("thread# %d i-1 %d, length %d\n", sort_this->thread_id, i-1, length[i-1]);
}
// TODO: free final_pivots double free detected error??
//free(final_pivots);
length[num_threads-1] = elements;
//printf("thread# %d i-1 %d, length %d\n", sort_this->thread_id, num_threads-1, length[num_threads-1]);
partitions[sort_this->thread_id].data = data;
partitions[sort_this->thread_id].length = length;
}
void __ompc_queue_lockless_init(omp_queue_t * q, int num_slots)
{
q->slots = aligned_malloc(
num_slots * sizeof(omp_queue_slot_t), CACHE_LINE_SIZE);
Is_True(q->slots != NULL,
("__ompc_queue_init: couldn't malloc slots for queue"));
memset(q->slots, 0, num_slots*sizeof(omp_queue_slot_t));
q->head = q->tail = q->slots;
q->num_slots = num_slots;
q->is_empty = 1;
q->head_index = q->tail_index = q->used_slots = q->reject = 0;
__ompc_init_lock(&q->lock1);
__ompc_init_lock(&q->lock2);
}
/*
* Combines llseek with blockwise write. write_blockwise can already deal with short writes
* but we also need a function to deal with short writes at the start. But this information
* is implicitly included in the read/write offset, which can not be set to non-aligned
* boundaries. Hence, we combine llseek with write.
*/
ssize_t write_lseek_blockwise(int fd, char *buf, size_t count, off_t offset) {
char *frontPadBuf;
void *frontPadBuf_base = NULL;
int r, bsize, frontHang;
size_t innerCount = 0;
ssize_t ret = -1;
if ((bsize = sector_size(fd)) < 0)
return bsize;
frontHang = offset % bsize;
if (lseek(fd, offset - frontHang, SEEK_SET) < 0)
goto out;
if (frontHang) {
frontPadBuf = aligned_malloc(&frontPadBuf_base,
bsize, get_alignment(fd));
if (!frontPadBuf)
goto out;
r = read(fd, frontPadBuf, bsize);
if (r < 0 || r != bsize)
goto out;
innerCount = bsize - frontHang;
if (innerCount > count)
innerCount = count;
memcpy(frontPadBuf + frontHang, buf, innerCount);
if (lseek(fd, offset - frontHang, SEEK_SET) < 0)
goto out;
r = write(fd, frontPadBuf, bsize);
if (r < 0 || r != bsize)
goto out;
buf += innerCount;
count -= innerCount;
}
ret = count ? write_blockwise(fd, buf, count) : 0;
if (ret >= 0)
ret += innerCount;
out:
free(frontPadBuf_base);
return ret;
}
// NOTE: Caller must free *image with aligned_malloc() from above.
void FloatArrayToByteArrayWithPadding(const Image<RGBfColor> &float_image,
unsigned char **image,
int *image_stride) {
// Allocate enough so that accessing 16 elements past the end is fine.
*image_stride = float_image.Width() + 16;
*image = static_cast<unsigned char *>(
aligned_malloc(*image_stride * float_image.Height(), 16));
for (int i = 0; i < float_image.Height(); ++i) {
for (int j = 0; j < float_image.Width(); ++j) {
(*image)[*image_stride * i + j] =
static_cast<unsigned char>(255.0 * float_image(i, j)(0));
}
}
}
