a12a8a71bb
The goal is to solve confusion of the "All rights reserved" for licensing
code under an open-source license.
The phrase "All rights reserved" comes from a historical convention that
required this phrase for the copyright protection to apply. This convention
is no longer relevant.
However, even though the phrase has no meaning in establishing the copyright
it has not lost meaning in terms of licensing.
This change makes it so code under the Blender Foundation copyright does
not use "all rights reserved". This is also how the GPL license itself
states how to apply it to the source code:
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software ...
This change does not change copyright notice in cases when the copyright
is dual (BF and an author), or just an author of the code. It also does
mot change copyright which is inherited from NaN Holding BV as it needs
some further investigation about what is the proper way to handle it.
56 lines
1.7 KiB
C
56 lines
1.7 KiB
C
/* SPDX-License-Identifier: GPL-2.0-or-later
|
|
* Copyright 2008 Blender Foundation */
|
|
|
|
#pragma once
|
|
|
|
/** \file
|
|
* \ingroup bli
|
|
*
|
|
* Shared logic for #BLI_task_parallel_mempool to create a threaded iterator,
|
|
* without exposing the these functions publicly.
|
|
*/
|
|
|
|
#include "BLI_compiler_attrs.h"
|
|
|
|
#include "BLI_mempool.h"
|
|
#include "BLI_task.h"
|
|
|
|
typedef struct BLI_mempool_threadsafe_iter {
|
|
BLI_mempool_iter iter;
|
|
struct BLI_mempool_chunk **curchunk_threaded_shared;
|
|
} BLI_mempool_threadsafe_iter;
|
|
|
|
typedef struct ParallelMempoolTaskData {
|
|
BLI_mempool_threadsafe_iter ts_iter;
|
|
TaskParallelTLS tls;
|
|
} ParallelMempoolTaskData;
|
|
|
|
/**
|
|
* Initialize an array of mempool iterators, #BLI_MEMPOOL_ALLOW_ITER flag must be set.
|
|
*
|
|
* This is used in threaded code, to generate as much iterators as needed
|
|
* (each task should have its own),
|
|
* such that each iterator goes over its own single chunk,
|
|
* and only getting the next chunk to iterate over has to be
|
|
* protected against concurrency (which can be done in a lock-less way).
|
|
*
|
|
* To be used when creating a task for each single item in the pool is totally overkill.
|
|
*
|
|
* See #BLI_task_parallel_mempool implementation for detailed usage example.
|
|
*/
|
|
ParallelMempoolTaskData *mempool_iter_threadsafe_create(BLI_mempool *pool,
|
|
size_t iter_num) ATTR_WARN_UNUSED_RESULT
|
|
ATTR_NONNULL();
|
|
void mempool_iter_threadsafe_destroy(ParallelMempoolTaskData *iter_arr) ATTR_NONNULL();
|
|
|
|
/**
|
|
* A version of #BLI_mempool_iterstep that uses
|
|
* #BLI_mempool_threadsafe_iter.curchunk_threaded_shared for threaded iteration support.
|
|
* (threaded section noted in comments).
|
|
*/
|
|
void *mempool_iter_threadsafe_step(BLI_mempool_threadsafe_iter *iter);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|