benkyd/tinyobjloader
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
629f1825c566750e416b8d8370528733a480bb76
tinyobjloader/experimental/optimized-parse.cc
Syoyo Fujita 5f4a557d69 Fix memory bug.
2016-05-25 19:48:25 +09:00

1239 lines
36 KiB
C++
Raw Blame History

//
//@todo { parse material. assign material id }
//@todo { support object&group }
//
#ifdef _WIN64
#define atoll(S) _atoi64(S)
#include <windows.h>
#else
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#endif
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>
#include <vector>
#include <iostream>
#include <chrono> // C++11
#include <thread> // C++11
#include <atomic> // C++11
#include "ltalloc.hpp"
// ----------------------------------------------------------------------------
// Small vector class useful for multi-threaded environment.
//
// stack_container.h
//
// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// This allocator can be used with STL containers to provide a stack buffer
// from which to allocate memory and overflows onto the heap. This stack buffer
// would be allocated on the stack and allows us to avoid heap operations in
// some situations.
//
// STL likes to make copies of allocators, so the allocator itself can't hold
// the data. Instead, we make the creator responsible for creating a
// StackAllocator::Source which contains the data. Copying the allocator
// merely copies the pointer to this shared source, so all allocators created
// based on our allocator will share the same stack buffer.
//
// This stack buffer implementation is very simple. The first allocation that
// fits in the stack buffer will use the stack buffer. Any subsequent
// allocations will not use the stack buffer, even if there is unused room.
// This makes it appropriate for array-like containers, but the caller should
// be sure to reserve() in the container up to the stack buffer size. Otherwise
// the container will allocate a small array which will "use up" the stack
// buffer.
template <typename T, size_t stack_capacity>
class StackAllocator : public std::allocator<T> {
public:
typedef typename std::allocator<T>::pointer pointer;
typedef typename std::allocator<T>::size_type size_type;
// Backing store for the allocator. The container owner is responsible for
// maintaining this for as long as any containers using this allocator are
// live.
struct Source {
Source() : used_stack_buffer_(false) {}
// Casts the buffer in its right type.
T *stack_buffer() { return reinterpret_cast<T *>(stack_buffer_); }
const T *stack_buffer() const {
return reinterpret_cast<const T *>(stack_buffer_);
}
//
// IMPORTANT: Take care to ensure that stack_buffer_ is aligned
// since it is used to mimic an array of T.
// Be careful while declaring any unaligned types (like bool)
// before stack_buffer_.
//
// The buffer itself. It is not of type T because we don't want the
// constructors and destructors to be automatically called. Define a POD
// buffer of the right size instead.
char stack_buffer_[sizeof(T[stack_capacity])];
// Set when the stack buffer is used for an allocation. We do not track
// how much of the buffer is used, only that somebody is using it.
bool used_stack_buffer_;
};
// Used by containers when they want to refer to an allocator of type U.
template <typename U>
struct rebind {
typedef StackAllocator<U, stack_capacity> other;
};
// For the straight up copy c-tor, we can share storage.
StackAllocator(const StackAllocator<T, stack_capacity> &rhs)
: source_(rhs.source_) {}
// ISO C++ requires the following constructor to be defined,
// and std::vector in VC++2008SP1 Release fails with an error
// in the class _Container_base_aux_alloc_real (from <xutility>)
// if the constructor does not exist.
// For this constructor, we cannot share storage; there's
// no guarantee that the Source buffer of Ts is large enough
// for Us.
// TODO(Google): If we were fancy pants, perhaps we could share storage
// iff sizeof(T) == sizeof(U).
template <typename U, size_t other_capacity>
StackAllocator(const StackAllocator<U, other_capacity> &other)
: source_(NULL) {
(void)other;
}
explicit StackAllocator(Source *source) : source_(source) {}
// Actually do the allocation. Use the stack buffer if nobody has used it yet
// and the size requested fits. Otherwise, fall through to the standard
// allocator.
pointer allocate(size_type n, void *hint = 0) {
if (source_ != NULL && !source_->used_stack_buffer_ &&
n <= stack_capacity) {
source_->used_stack_buffer_ = true;
return source_->stack_buffer();
} else {
return std::allocator<T>::allocate(n, hint);
}
}
// Free: when trying to free the stack buffer, just mark it as free. For
// non-stack-buffer pointers, just fall though to the standard allocator.
void deallocate(pointer p, size_type n) {
if (source_ != NULL && p == source_->stack_buffer())
source_->used_stack_buffer_ = false;
else
std::allocator<T>::deallocate(p, n);
}
private:
Source *source_;
};
// A wrapper around STL containers that maintains a stack-sized buffer that the
// initial capacity of the vector is based on. Growing the container beyond the
// stack capacity will transparently overflow onto the heap. The container must
// support reserve().
//
// WATCH OUT: the ContainerType MUST use the proper StackAllocator for this
// type. This object is really intended to be used only internally. You'll want
// to use the wrappers below for different types.
template <typename TContainerType, int stack_capacity>
class StackContainer {
public:
typedef TContainerType ContainerType;
typedef typename ContainerType::value_type ContainedType;
typedef StackAllocator<ContainedType, stack_capacity> Allocator;
// Allocator must be constructed before the container!
StackContainer() : allocator_(&stack_data_), container_(allocator_) {
// Make the container use the stack allocation by reserving our buffer size
// before doing anything else.
container_.reserve(stack_capacity);
}
// Getters for the actual container.
//
// Danger: any copies of this made using the copy constructor must have
// shorter lifetimes than the source. The copy will share the same allocator
// and therefore the same stack buffer as the original. Use std::copy to
// copy into a "real" container for longer-lived objects.
ContainerType &container() { return container_; }
const ContainerType &container() const { return container_; }
// Support operator-> to get to the container. This allows nicer syntax like:
// StackContainer<...> foo;
// std::sort(foo->begin(), foo->end());
ContainerType *operator->() { return &container_; }
const ContainerType *operator->() const { return &container_; }
#ifdef UNIT_TEST
// Retrieves the stack source so that that unit tests can verify that the
// buffer is being used properly.
const typename Allocator::Source &stack_data() const { return stack_data_; }
#endif
protected:
typename Allocator::Source stack_data_;
unsigned char pad_[7];
Allocator allocator_;
ContainerType container_;
// DISALLOW_EVIL_CONSTRUCTORS(StackContainer);
StackContainer(const StackContainer &);
void operator=(const StackContainer &);
};
// StackVector
//
// Example:
// StackVector<int, 16> foo;
// foo->push_back(22); // we have overloaded operator->
// foo[0] = 10; // as well as operator[]
template <typename T, size_t stack_capacity>
class StackVector
: public StackContainer<std::vector<T, StackAllocator<T, stack_capacity> >,
stack_capacity> {
public:
StackVector()
: StackContainer<std::vector<T, StackAllocator<T, stack_capacity> >,
stack_capacity>() {}
// We need to put this in STL containers sometimes, which requires a copy
// constructor. We can't call the regular copy constructor because that will
// take the stack buffer from the original. Here, we create an empty object
// and make a stack buffer of its own.
StackVector(const StackVector<T, stack_capacity> &other)
: StackContainer<std::vector<T, StackAllocator<T, stack_capacity> >,
stack_capacity>() {
this->container().assign(other->begin(), other->end());
}
StackVector<T, stack_capacity> &operator=(
const StackVector<T, stack_capacity> &other) {
this->container().assign(other->begin(), other->end());
return *this;
}
// Vectors are commonly indexed, which isn't very convenient even with
// operator-> (using "->at()" does exception stuff we don't want).
T &operator[](size_t i) { return this->container().operator[](i); }
const T &operator[](size_t i) const {
return this->container().operator[](i);
}
};
// ----------------------------------------------------------------------------
typedef StackVector<char, 256> ShortString;
#define IS_SPACE(x) (((x) == ' ') || ((x) == '\t'))
#define IS_DIGIT(x) \
(static_cast<unsigned int>((x) - '0') < static_cast<unsigned int>(10))
#define IS_NEW_LINE(x) (((x) == '\r') || ((x) == '\n') || ((x) == '\0'))
static inline void skip_space(const char **token)
{
while ((*token)[0] == ' ' || (*token)[0] == '\t') {
(*token)++;
}
}
static inline void skip_space_and_cr(const char **token)
{
while ((*token)[0] == ' ' || (*token)[0] == '\t' || (*token)[0] == '\r') {
(*token)++;
}
}
static inline int until_space(const char *token)
{
const char *p = token;
while (p[0] != '\0' && p[0] != ' ' && p[0] != '\t' && p[0] != '\r') {
p++;
}
return p - token;
}
static inline int length_until_newline(const char *token, int n)
{
int len = 0;
// Assume token[n-1] = '\0'
for (len = 0; len < n -1; len++) {
if (token[len] == '\n') {
break;
}
if ((token[len] == '\r') && ((len < (n-2)) && (token[len+1] != '\n'))) {
break;
}
}
return len;
}
// http://stackoverflow.com/questions/5710091/how-does-atoi-function-in-c-work
static inline int my_atoi( const char *c ) {
int value = 0;
int sign = 1;
if( *c == '+' || *c == '-' ) {
if( *c == '-' ) sign = -1;
c++;
}
while ( ((*c) >= '0') && ((*c) <= '9') ) { // isdigit(*c)
value *= 10;
value += (int) (*c-'0');
c++;
}
return value * sign;
}
struct vertex_index {
int v_idx, vt_idx, vn_idx;
vertex_index() : v_idx(-1), vt_idx(-1), vn_idx(-1) {}
explicit vertex_index(int idx) : v_idx(idx), vt_idx(idx), vn_idx(idx) {}
vertex_index(int vidx, int vtidx, int vnidx)
: v_idx(vidx), vt_idx(vtidx), vn_idx(vnidx) {}
};
// Make index zero-base, and also support relative index.
static inline int fixIndex(int idx, int n) {
if (idx > 0) return idx - 1;
if (idx == 0) return 0;
return n + idx; // negative value = relative
}
#if 0
// Parse triples with index offsets: i, i/j/k, i//k, i/j
static vertex_index parseTriple(const char **token, int vsize, int vnsize,
int vtsize) {
vertex_index vi(-1);
vi.v_idx = fixIndex(my_atoi((*token)), vsize);
//(*token) += strcspn((*token), "/ \t\r");
while ((*token)[0] != '\0' && (*token)[0] != '/' && (*token)[0] != ' ' && (*token)[0] != '\t' && (*token)[0] != '\r') {
(*token)++;
}
if ((*token)[0] != '/') {
return vi;
}
(*token)++;
// i//k
if ((*token)[0] == '/') {
(*token)++;
vi.vn_idx = fixIndex(my_atoi((*token)), vnsize);
//(*token) += strcspn((*token), "/ \t\r");
while ((*token)[0] != '\0' && (*token)[0] != '/' && (*token)[0] != ' ' && (*token)[0] != '\t' && (*token)[0] != '\r') {
(*token)++;
}
return vi;
}
// i/j/k or i/j
vi.vt_idx = fixIndex(my_atoi((*token)), vtsize);
//(*token) += strcspn((*token), "/ \t\r");
while ((*token)[0] != '\0' && (*token)[0] != '/' && (*token)[0] != ' ' && (*token)[0] != '\t' && (*token)[0] != '\r') {
(*token)++;
}
if ((*token)[0] != '/') {
return vi;
}
// i/j/k
(*token)++; // skip '/'
vi.vn_idx = fixIndex(my_atoi((*token)), vnsize);
//(*token) += strcspn((*token), "/ \t\r");
while ((*token)[0] != '\0' && (*token)[0] != '/' && (*token)[0] != ' ' && (*token)[0] != '\t' && (*token)[0] != '\r') {
(*token)++;
}
return vi;
}
#endif
// Parse raw triples: i, i/j/k, i//k, i/j
static vertex_index parseRawTriple(const char **token) {
vertex_index vi(
static_cast<int>(0x80000000)); // 0x80000000 = -2147483648 = invalid
vi.v_idx = my_atoi((*token));
//(*token) += strcspn((*token), "/ \t\r");
while ((*token)[0] != '\0' && (*token)[0] != '/' && (*token)[0] != ' ' && (*token)[0] != '\t' && (*token)[0] != '\r') {
(*token)++;
}
if ((*token)[0] != '/') {
return vi;
}
(*token)++;
// i//k
if ((*token)[0] == '/') {
(*token)++;
vi.vn_idx = my_atoi((*token));
//(*token) += strcspn((*token), "/ \t\r");
while ((*token)[0] != '\0' && (*token)[0] != '/' && (*token)[0] != ' ' && (*token)[0] != '\t' && (*token)[0] != '\r') {
(*token)++;
}
return vi;
}
// i/j/k or i/j
vi.vt_idx = my_atoi((*token));
//(*token) += strcspn((*token), "/ \t\r");
while ((*token)[0] != '\0' && (*token)[0] != '/' && (*token)[0] != ' ' && (*token)[0] != '\t' && (*token)[0] != '\r') {
(*token)++;
}
if ((*token)[0] != '/') {
return vi;
}
// i/j/k
(*token)++; // skip '/'
vi.vn_idx = my_atoi((*token));
//(*token) += strcspn((*token), "/ \t\r");
while ((*token)[0] != '\0' && (*token)[0] != '/' && (*token)[0] != ' ' && (*token)[0] != '\t' && (*token)[0] != '\r') {
(*token)++;
}
return vi;
}
static inline bool parseString(ShortString *s, const char **token) {
skip_space(token); //(*token) += strspn((*token), " \t");
size_t e = until_space((*token)); //strcspn((*token), " \t\r");
(*s)->insert((*s)->end(), (*token), (*token) + e);
(*token) += e;
return true;
}
static inline int parseInt(const char **token) {
skip_space(token); //(*token) += strspn((*token), " \t");
int i = my_atoi((*token));
(*token) += until_space((*token)); //strcspn((*token), " \t\r");
return i;
}
// Tries to parse a floating point number located at s.
//
// s_end should be a location in the string where reading should absolutely
// stop. For example at the end of the string, to prevent buffer overflows.
//
// Parses the following EBNF grammar:
// sign = "+" | "-" ;
// END = ? anything not in digit ?
// digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
// integer = [sign] , digit , {digit} ;
// decimal = integer , ["." , integer] ;
// float = ( decimal , END ) | ( decimal , ("E" | "e") , integer , END ) ;
//
// Valid strings are for example:
// -0 +3.1417e+2 -0.0E-3 1.0324 -1.41 11e2
//
// If the parsing is a success, result is set to the parsed value and true
// is returned.
//
// The function is greedy and will parse until any of the following happens:
// - a non-conforming character is encountered.
// - s_end is reached.
//
// The following situations triggers a failure:
// - s >= s_end.
// - parse failure.
//
static bool tryParseDouble(const char *s, const char *s_end, double *result) {
if (s >= s_end) {
return false;
}
double mantissa = 0.0;
// This exponent is base 2 rather than 10.
// However the exponent we parse is supposed to be one of ten,
// thus we must take care to convert the exponent/and or the
// mantissa to a * 2^E, where a is the mantissa and E is the
// exponent.
// To get the final double we will use ldexp, it requires the
// exponent to be in base 2.
int exponent = 0;
// NOTE: THESE MUST BE DECLARED HERE SINCE WE ARE NOT ALLOWED
// TO JUMP OVER DEFINITIONS.
char sign = '+';
char exp_sign = '+';
char const *curr = s;
// How many characters were read in a loop.
int read = 0;
// Tells whether a loop terminated due to reaching s_end.
bool end_not_reached = false;
/*
BEGIN PARSING.
*/
// Find out what sign we've got.
if (*curr == '+' || *curr == '-') {
sign = *curr;
curr++;
} else if (IS_DIGIT(*curr)) { /* Pass through. */
} else {
goto fail;
}
// Read the integer part.
end_not_reached = (curr != s_end);
while (end_not_reached && IS_DIGIT(*curr)) {
mantissa *= 10;
mantissa += static_cast<int>(*curr - 0x30);
curr++;
read++;
end_not_reached = (curr != s_end);
}
// We must make sure we actually got something.
if (read == 0) goto fail;
// We allow numbers of form "#", "###" etc.
if (!end_not_reached) goto assemble;
// Read the decimal part.
if (*curr == '.') {
curr++;
read = 1;
end_not_reached = (curr != s_end);
while (end_not_reached && IS_DIGIT(*curr)) {
// NOTE: Don't use powf here, it will absolutely murder precision.
// pow(10.0, -read)
double frac_value = 1.0;
for (int f = 0; f < read; f++) {
frac_value *= 0.1;
}
mantissa += static_cast<int>(*curr - 0x30) * frac_value;
read++;
curr++;
end_not_reached = (curr != s_end);
}
} else if (*curr == 'e' || *curr == 'E') {
} else {
goto assemble;
}
if (!end_not_reached) goto assemble;
// Read the exponent part.
if (*curr == 'e' || *curr == 'E') {
curr++;
// Figure out if a sign is present and if it is.
end_not_reached = (curr != s_end);
if (end_not_reached && (*curr == '+' || *curr == '-')) {
exp_sign = *curr;
curr++;
} else if (IS_DIGIT(*curr)) { /* Pass through. */
} else {
// Empty E is not allowed.
goto fail;
}
read = 0;
end_not_reached = (curr != s_end);
while (end_not_reached && IS_DIGIT(*curr)) {
exponent *= 10;
exponent += static_cast<int>(*curr - 0x30);
curr++;
read++;
end_not_reached = (curr != s_end);
}
exponent *= (exp_sign == '+' ? 1 : -1);
if (read == 0) goto fail;
}
assemble:
*result =
(sign == '+' ? 1 : -1) * ldexp(mantissa * pow(5.0, exponent), exponent);
return true;
fail:
return false;
}
static inline float parseFloat(const char **token) {
skip_space(token); //(*token) += strspn((*token), " \t");
#ifdef TINY_OBJ_LOADER_OLD_FLOAT_PARSER
float f = static_cast<float>(atof(*token));
(*token) += strcspn((*token), " \t\r");
#else
const char *end = (*token) + until_space((*token)); //strcspn((*token), " \t\r");
double val = 0.0;
tryParseDouble((*token), end, &val);
float f = static_cast<float>(val);
(*token) = end;
#endif
return f;
}
static inline void parseFloat2(float *x, float *y, const char **token) {
(*x) = parseFloat(token);
(*y) = parseFloat(token);
}
static inline void parseFloat3(float *x, float *y, float *z,
const char **token) {
(*x) = parseFloat(token);
(*y) = parseFloat(token);
(*z) = parseFloat(token);
}
typedef enum
{
COMMAND_EMPTY,
COMMAND_V,
COMMAND_VN,
COMMAND_VT,
COMMAND_F,
COMMAND_G,
COMMAND_O,
COMMAND_USEMTL,
} CommandType;
typedef struct
{
float vx, vy, vz;
float nx, ny, nz;
float tx, ty;
// for f
std::vector<vertex_index, lt::allocator<vertex_index> > f;
//std::vector<vertex_index> f;
const char* group_name;
unsigned int group_name_len;
const char* object_name;
unsigned int object_name_len;
const char* material_name;
unsigned int material_name_len;
CommandType type;
} Command;
struct CommandCount
{
size_t num_v;
size_t num_vn;
size_t num_vt;
size_t num_f;
CommandCount() {
num_v = 0;
num_vn = 0;
num_vt = 0;
num_f = 0;
}
};
static bool parseLine(Command *command, const char *p, size_t p_len, bool triangulate = true)
{
char linebuf[4096];
assert(p_len < 4095);
//StackVector<char, 256> linebuf;
//linebuf->resize(p_len + 1);
memcpy(&linebuf, p, p_len);
linebuf[p_len] = '\0';
const char *token = linebuf;
command->type = COMMAND_EMPTY;
// Skip leading space.
//token += strspn(token, " \t");
skip_space(&token); //(*token) += strspn((*token), " \t");
assert(token);
if (token[0] == '\0') { // empty line
return false;
}
if (token[0] == '#') { // comment line
return false;
}
// vertex
if (token[0] == 'v' && IS_SPACE((token[1]))) {
token += 2;
float x, y, z;
parseFloat3(&x, &y, &z, &token);
command->vx = x;
command->vy = y;
command->vz = z;
command->type = COMMAND_V;
return true;
}
// normal
if (token[0] == 'v' && token[1] == 'n' && IS_SPACE((token[2]))) {
token += 3;
float x, y, z;
parseFloat3(&x, &y, &z, &token);
command->nx = x;
command->ny = y;
command->nz = z;
command->type = COMMAND_VN;
return true;
}
// texcoord
if (token[0] == 'v' && token[1] == 't' && IS_SPACE((token[2]))) {
token += 3;
float x, y;
parseFloat2(&x, &y, &token);
command->tx = x;
command->ty = y;
command->type = COMMAND_VT;
return true;
}
// face
if (token[0] == 'f' && IS_SPACE((token[1]))) {
token += 2;
//token += strspn(token, " \t");
skip_space(&token);
StackVector<vertex_index, 8> f;
while (!IS_NEW_LINE(token[0])) {
vertex_index vi = parseRawTriple(&token);
//printf("v = %d, %d, %d\n", vi.v_idx, vi.vn_idx, vi.vt_idx);
//if (callback.index_cb) {
// callback.index_cb(user_data, vi.v_idx, vi.vn_idx, vi.vt_idx);
//}
//size_t n = strspn(token, " \t\r");
//token += n;
skip_space_and_cr(&token);
f->push_back(vi);
}
command->type = COMMAND_F;
if (triangulate) {
vertex_index i0 = f[0];
vertex_index i1(-1);
vertex_index i2 = f[1];
for (size_t k = 2; k < f->size(); k++) {
i1 = i2;
i2 = f[k];
command->f.emplace_back(i0);
command->f.emplace_back(i1);
command->f.emplace_back(i2);
}
} else {
for (size_t k = 0; k < f->size(); k++) {
command->f.emplace_back(f[k]);
}
}
return true;
}
// use mtl
if ((0 == strncmp(token, "usemtl", 6)) && IS_SPACE((token[6]))) {
token += 7;
//int newMaterialId = -1;
//if (material_map.find(namebuf) != material_map.end()) {
// newMaterialId = material_map[namebuf];
//} else {
// // { error!! material not found }
//}
//if (newMaterialId != materialId) {
// materialId = newMaterialId;
//}
//command->material_name = .insert(command->material_name->end(), namebuf, namebuf + strlen(namebuf));
//command->material_name->push_back('\0');
skip_space(&token);
command->material_name = token;
command->material_name_len = length_until_newline(token, p_len - (token - linebuf));
command->type = COMMAND_USEMTL;
return true;
}
// load mtl
if ((0 == strncmp(token, "mtllib", 6)) && IS_SPACE((token[6]))) {
// By specification, `mtllib` should be appaar only once in .obj
char namebuf[8192];
token += 7;
#ifdef _MSC_VER
sscanf_s(token, "%s", namebuf, (unsigned)_countof(namebuf));
#else
sscanf(token, "%s", namebuf);
#endif
//std::string err_mtl;
//std::vector<material_t> materials;
//bool ok = (*readMatFn)(namebuf, &materials, &material_map, &err_mtl);
//if (err) {
// (*err) += err_mtl;
//}
//if (!ok) {
// return false;
//}
//if (callback.mtllib_cb) {
// callback.mtllib_cb(user_data, &materials.at(0),
// static_cast<int>(materials.size()));
//}
return true;
}
// group name
if (token[0] == 'g' && IS_SPACE((token[1]))) {
#if 0
ShortString names[16];
int num_names = 0;
while (!IS_NEW_LINE(token[0])) {
bool ret = parseString(&(names[num_names]), &token);
assert(ret);
token += strspn(token, " \t\r"); // skip tag
num_names++;
}
assert(num_names > 0);
int name_idx = 0;
// names[0] must be 'g', so skip the 0th element.
if (num_names > 1) {
name_idx = 1;
}
#endif
token += 2;
command->group_name = token;
command->group_name_len = length_until_newline(token, p_len - (token - linebuf));
command->type = COMMAND_G;
return true;
}
// object name
if (token[0] == 'o' && IS_SPACE((token[1]))) {
#if 0
// @todo { multiple object name? }
char namebuf[8192];
token += 2;
#ifdef _MSC_VER
sscanf_s(token, "%s", namebuf, (unsigned)_countof(namebuf));
#else
sscanf(token, "%s", namebuf);
#endif
#endif
token += 2;
command->object_name = token;
command->object_name_len = length_until_newline(token, p_len - (token - linebuf));
command->type = COMMAND_O;
return true;
}
return false;
}
typedef struct
{
size_t pos;
size_t len;
} LineInfo;
// Idea come from https://github.com/antonmks/nvParse
// 1. mmap file
// 2. find newline(\n, \r\n, \r) and list of line data.
// 3. Do parallel parsing for each line.
// 4. Reconstruct final mesh data structure.
#define kMaxThreads (32)
static inline bool is_line_ending(const char* p, size_t i, size_t end_i)
{
if (p[i] == '\0') return true;
if (p[i] == '\n') return true; // this includes \r\n
if (p[i] == '\r') {
if (((i+1) < end_i) && (p[i+1] != '\n')) { // detect only \r case
return true;
}
}
return false;
}
bool parse(std::vector<float, lt::allocator<float>> &vertices, std::vector<float, lt::allocator<float>> &normals, std::vector<float, lt::allocator<float>> &texcoords, std::vector<vertex_index, lt::allocator<vertex_index>> &faces, const char* buf, size_t len, int req_num_threads)
{
vertices.clear();
normals.clear();
texcoords.clear();
faces.clear();
if (len < 1) return false;
std::cout << "parse" << std::endl;
auto num_threads = (req_num_threads < 0) ? std::thread::hardware_concurrency() : req_num_threads;
num_threads = std::max(1, std::min(static_cast<int>(num_threads), kMaxThreads));
std::cout << "# of threads = " << num_threads << std::endl;
auto t1 = std::chrono::high_resolution_clock::now();
std::vector<LineInfo, lt::allocator<LineInfo>> line_infos[kMaxThreads];
for (size_t t = 0; t < static_cast<size_t>(num_threads); t++) {
// Pre allocate enough memory. len / 128 / num_threads is just a heuristic value.
line_infos[t].reserve(len / 128 / num_threads);
}
std::chrono::duration<double, std::milli> ms_linedetection;
std::chrono::duration<double, std::milli> ms_alloc;
std::chrono::duration<double, std::milli> ms_parse;
std::chrono::duration<double, std::milli> ms_merge;
// 1. Find '\n' and create line data.
{
StackVector<std::thread, 16> workers;
auto start_time = std::chrono::high_resolution_clock::now();
auto chunk_size = len / num_threads;
for (size_t t = 0; t < static_cast<size_t>(num_threads); t++) {
workers->push_back(std::thread([&, t]() {
auto start_idx = (t + 0) * chunk_size;
auto end_idx = std::min((t + 1) * chunk_size, len - 1);
if (t == static_cast<size_t>((num_threads - 1))) {
end_idx = len - 1;
}
size_t prev_pos = start_idx;
for (size_t i = start_idx; i < end_idx; i++) {
if (is_line_ending(buf, i, end_idx)) {
if ((t > 0) && (prev_pos == start_idx) && (!is_line_ending(buf, start_idx-1, end_idx))) {
// first linebreak found in (chunk > 0), and a line before this linebreak belongs to previous chunk, so skip it.
prev_pos = i + 1;
continue;
} else {
LineInfo info;
info.pos = prev_pos;
info.len = i - prev_pos;
if (info.len > 0) {
line_infos[t].push_back(info);
}
prev_pos = i+1;
}
}
}
// Find extra line which spand across chunk boundary.
if ((t < num_threads) && (buf[end_idx-1] != '\n')) {
auto extra_span_idx = std::min(end_idx-1+chunk_size, len - 1);
for (size_t i = end_idx; i < extra_span_idx; i++) {
if (is_line_ending(buf, i, extra_span_idx)) {
LineInfo info;
info.pos = prev_pos;
info.len = i - prev_pos;
if (info.len > 0) {
line_infos[t].push_back(info);
}
break;
}
}
}
}));
}
for (size_t t = 0; t < workers->size(); t++) {
workers[t].join();
}
auto end_time = std::chrono::high_resolution_clock::now();
ms_linedetection = end_time - start_time;
}
auto line_sum = 0;
for (size_t t = 0; t < num_threads; t++) {
//std::cout << t << ": # of lines = " << line_infos[t].size() << std::endl;
line_sum += line_infos[t].size();
}
//std::cout << "# of lines = " << line_sum << std::endl;
std::vector<Command> commands[kMaxThreads];
//thread_local std::vector<Command, lt::allocator<Command> > commands;
// 2. allocate buffer
auto t_alloc_start = std::chrono::high_resolution_clock::now();
{
for (size_t t = 0; t < num_threads; t++) {
commands[t].reserve(line_infos[t].size());
}
}
CommandCount command_count[kMaxThreads];
ms_alloc = std::chrono::high_resolution_clock::now() - t_alloc_start;
// 2. parse each line in parallel.
{
StackVector<std::thread, 16> workers;
auto t_start = std::chrono::high_resolution_clock::now();
for (size_t t = 0; t < num_threads; t++) {
workers->push_back(std::thread([&, t]() {
for (size_t i = 0; i < line_infos[t].size(); i++) {
Command command;
bool ret = parseLine(&command, &buf[line_infos[t][i].pos], line_infos[t][i].len);
if (ret) {
if (command.type == COMMAND_V) {
command_count[t].num_v++;
} else if (command.type == COMMAND_VN) {
command_count[t].num_vn++;
} else if (command.type == COMMAND_VT) {
command_count[t].num_vt++;
} else if (command.type == COMMAND_F) {
command_count[t].num_f += command.f.size();
}
commands[t].emplace_back(std::move(command));
}
}
}));
}
for (size_t t = 0; t < workers->size(); t++) {
workers[t].join();
}
auto t_end = std::chrono::high_resolution_clock::now();
ms_parse = t_end - t_start;
}
auto command_sum = 0;
for (size_t t = 0; t < num_threads; t++) {
//std::cout << t << ": # of commands = " << commands[t].size() << std::endl;
command_sum += commands[t].size();
}
//std::cout << "# of commands = " << command_sum << std::endl;
size_t num_v = 0;
size_t num_vn = 0;
size_t num_vt = 0;
size_t num_f = 0;
for (size_t t = 0; t < num_threads; t++) {
num_v += command_count[t].num_v;
num_vn += command_count[t].num_vn;
num_vt += command_count[t].num_vt;
num_f += command_count[t].num_f;
}
//std::cout << "# v " << num_v << std::endl;
//std::cout << "# vn " << num_vn << std::endl;
//std::cout << "# vt " << num_vt << std::endl;
//std::cout << "# f " << num_f << std::endl;
// 4. merge
// @todo { parallelize merge. }
{
auto t_start = std::chrono::high_resolution_clock::now();
vertices.resize(num_v * 3);
normals.resize(num_vn * 3);
texcoords.resize(num_vt * 2);
faces.resize(num_f);
size_t v_count = 0;
size_t n_count = 0;
size_t t_count = 0;
size_t f_count = 0;
for (size_t t = 0; t < num_threads; t++) {
for (size_t i = 0; i < commands[t].size(); i++) {
if (commands[t][i].type == COMMAND_EMPTY) {
continue;
} else if (commands[t][i].type == COMMAND_V) {
vertices[3*v_count+0] = commands[t][i].vx;
vertices[3*v_count+1] = commands[t][i].vy;
vertices[3*v_count+2] = commands[t][i].vz;
v_count++;
} else if (commands[t][i].type == COMMAND_VN) {
normals[3*n_count+0] = commands[t][i].nx;
normals[3*n_count+1] = commands[t][i].ny;
normals[3*n_count+2] = commands[t][i].nz;
n_count++;
} else if (commands[t][i].type == COMMAND_VT) {
texcoords[2*t_count+0] = commands[t][i].tx;
texcoords[2*t_count+1] = commands[t][i].ty;
t_count++;
} else if (commands[t][i].type == COMMAND_F) {
#if 0
int v_size = vertices.size() / 3;
int vn_size = normals.size() / 3;
int vt_size = texcoords.size() / 2;
// triangulate.
{
vertex_index i0 = commands[t][i].f[0];
vertex_index i1(-1);
vertex_index i2 = commands[t][i].f[1];
for (size_t k = 2; k < commands[t][i].f.size(); k++) {
i1 = i2;
i2 = commands[t][i].f[k];
int v_idx = fixIndex(i0.v_idx, v_size);
int vn_idx = fixIndex(i0.vn_idx, vn_size);
int vt_idx = fixIndex(i0.vt_idx, vt_size);
faces.emplace_back(std::move(vertex_index(v_idx, vt_idx, vn_idx)));
v_idx = fixIndex(i1.v_idx, v_size);
vn_idx = fixIndex(i1.vn_idx, vn_size);
vt_idx = fixIndex(i1.vt_idx, vt_size);
faces.emplace_back(std::move(vertex_index(v_idx, vt_idx, vn_idx)));
v_idx = fixIndex(i2.v_idx, v_size);
vn_idx = fixIndex(i2.vn_idx, vn_size);
vt_idx = fixIndex(i2.vt_idx, vt_size);
faces.emplace_back(std::move(vertex_index(v_idx, vt_idx, vn_idx)));
}
}
#else
for (size_t k = 0; k < commands[t][i].f.size(); k++) {
vertex_index &vi = commands[t][i].f[k];
int v_idx = fixIndex(vi.v_idx, v_count);
int vn_idx = fixIndex(vi.vn_idx, n_count);
int vt_idx = fixIndex(vi.vt_idx, t_count);
faces[f_count + k] = vertex_index(v_idx, vn_idx, vt_idx);
}
f_count += commands[t][i].f.size();
#endif
}
}
}
auto t_end = std::chrono::high_resolution_clock::now();
ms_merge = t_end - t_start;
}
auto t4 = std::chrono::high_resolution_clock::now();
std::chrono::duration<double, std::milli> ms_total = t4 - t1;
std::cout << "total parsing time: " << ms_total.count() << " ms\n";
std::cout << " line detection :" << ms_linedetection.count() << " ms\n";
std::cout << " alloc buf :" << ms_alloc.count() << " ms\n";
std::cout << " parse :" << ms_parse.count() << " ms\n";
std::cout << " merge :" << ms_merge.count() << " ms\n";
std::cout << "# of vertices = " << vertices.size() << std::endl;
std::cout << "# of normals = " << normals.size() << std::endl;
std::cout << "# of texcoords = " << texcoords.size() << std::endl;
std::cout << "# of faces = " << faces.size() << std::endl;
return true;
}
#ifdef CONSOLE_TEST
int
main(int argc, char **argv)
{
if (argc < 2) {
printf("Needs .obj\n");
return EXIT_FAILURE;
}
int req_num_threads = -1;
if (argc > 2) {
req_num_threads = atoi(argv[2]);
}
#ifdef _WIN64
HANDLE file = CreateFileA(argv[1], GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
assert(file != INVALID_HANDLE_VALUE);
HANDLE fileMapping = CreateFileMapping(file, NULL, PAGE_READONLY, 0, 0, NULL);
assert(fileMapping != INVALID_HANDLE_VALUE);
LPVOID fileMapView = MapViewOfFile(fileMapping, FILE_MAP_READ, 0, 0, 0);
auto fileMapViewChar = (const char*)fileMapView;
assert(fileMapView != NULL);
#else
FILE* f = fopen(argv[1], "r" );
fseek(f, 0, SEEK_END);
long fileSize = ftell(f);
fclose(f);
struct stat sb;
char *p;
int fd;
fd = open (argv[1], O_RDONLY);
if (fd == -1) {
perror ("open");
return 1;
}
if (fstat (fd, &sb) == -1) {
perror ("fstat");
return 1;
}
if (!S_ISREG (sb.st_mode)) {
fprintf (stderr, "%s is not a file\n", "lineitem.tbl");
return 1;
}
p = (char*)mmap (0, fileSize, PROT_READ, MAP_SHARED, fd, 0);
if (p == MAP_FAILED) {
perror ("mmap");
return 1;
}
if (close (fd) == -1) {
perror ("close");
return 1;
}
printf("fsize: %lu\n", fileSize);
#endif
parse(p, fileSize, req_num_threads);
return EXIT_SUCCESS;
}
#endif
Reference in New Issue View Git Blame Copy Permalink