This question is unlikely to help any future visitors; it is only relevant to a small geographic area, a specific moment in time, or an extraordinarily narrow situation that is not generally applicable to the worldwide audience of the internet. For help making this question more broadly applicable, visit the help center.
Closed 10 years ago.
so I have this python script here, and I am trying to run it but I get a syntax error. I do not see anything wrong with the syntax. Here is the code:
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#define KSYM_NAME_LEN 127
struct sym_entry {
unsigned long long addr;
unsigned int len;
unsigned char *sym;
};
static struct sym_entry *table;
static unsigned int table_size, table_cnt;
static unsigned long long _text, _stext, _etext, _sinittext, _einittext, _sextratext, _eextratext;
static int all_symbols = 0;
static char symbol_prefix_char = '\0';
int token_profit[0x10000];
/* the table that holds the result of the compression */
unsigned char best_table[256][2];
unsigned char best_table_len[256];
static void usage(void)
{
fprintf(stderr, "Usage: kallsyms [--all-symbols] [--symbol-prefix=<prefix char>] < in.map > out.S\n");
exit(1);
}
/*
* This ignores the intensely annoying "mapping symbols" found
* in ARM ELF files: $a, $t and $d.
*/
static inline int is_arm_mapping_symbol(const char *str)
{
return str[0] == '$' && strchr("atd", str[1])
&& (str[2] == '\0' || str[2] == '.');
}
static int read_symbol(FILE *in, struct sym_entry *s)
{
char str[500];
char *sym, stype;
int rc;
rc = fscanf(in, "%llx %c %499s\n", &s->addr, &stype, str);
if (rc != 3) {
if (rc != EOF) {
/* skip line */
fgets(str, 500, in);
}
return -1;
}
sym = str;
/* skip prefix char */
if (symbol_prefix_char && str[0] == symbol_prefix_char)
sym++;
/* Ignore most absolute/undefined (?) symbols. */
if (strcmp(sym, "_text") == 0)
_text = s->addr;
else if (strcmp(sym, "_stext") == 0)
_stext = s->addr;
else if (strcmp(sym, "_etext") == 0)
_etext = s->addr;
else if (strcmp(sym, "_sinittext") == 0)
_sinittext = s->addr;
else if (strcmp(sym, "_einittext") == 0)
_einittext = s->addr;
else if (strcmp(sym, "_sextratext") == 0)
_sextratext = s->addr;
else if (strcmp(sym, "_eextratext") == 0)
_eextratext = s->addr;
else if (toupper(stype) == 'A')
{
/* Keep these useful absolute symbols */
if (strcmp(sym, "__kernel_syscall_via_break") &&
strcmp(sym, "__kernel_syscall_via_epc") &&
strcmp(sym, "__kernel_sigtramp") &&
strcmp(sym, "__gp"))
return -1;
}
else if (toupper(stype) == 'U' ||
is_arm_mapping_symbol(sym))
return -1;
/* exclude also MIPS ELF local symbols ($L123 instead of .L123) */
else if (str[0] == '$')
return -1;
/* include the type field in the symbol name, so that it gets
* compressed together */
s->len = strlen(str) + 1;
s->sym = malloc(s->len + 1);
if (!s->sym) {
fprintf(stderr, "kallsyms failure: "
"unable to allocate required amount of memory\n");
exit(EXIT_FAILURE);
}
strcpy((char *)s->sym + 1, str);
s->sym[0] = stype;
return 0;
}
static int symbol_valid(struct sym_entry *s)
{
/* Symbols which vary between passes. Passes 1 and 2 must have
* identical symbol lists. The kallsyms_* symbols below are only added
* after pass 1, they would be included in pass 2 when --all-symbols is
* specified so exclude them to get a stable symbol list.
*/
static char *special_symbols[] = {
"kallsyms_addresses",
"kallsyms_num_syms",
"kallsyms_names",
"kallsyms_markers",
"kallsyms_token_table",
"kallsyms_token_index",
/* Exclude linker generated symbols which vary between passes */
"_SDA_BASE_", /* ppc */
"_SDA2_BASE_", /* ppc */
NULL };
int i;
int offset = 1;
/* skip prefix char */
if (symbol_prefix_char && *(s->sym + 1) == symbol_prefix_char)
offset++;
/* if --all-symbols is not specified, then symbols outside the text
* and inittext sections are discarded */
if (!all_symbols) {
if ((s->addr < _stext || s->addr > _etext)
&& (s->addr < _sinittext || s->addr > _einittext)
&& (s->addr < _sextratext || s->addr > _eextratext))
return 0;
/* Corner case. Discard any symbols with the same value as
* _etext _einittext or _eextratext; they can move between pass
* 1 and 2 when the kallsyms data are added. If these symbols
* move then they may get dropped in pass 2, which breaks the
* kallsyms rules.
*/
if ((s->addr == _etext && strcmp((char*)s->sym + offset, "_etext")) ||
(s->addr == _einittext && strcmp((char*)s->sym + offset, "_einittext")) ||
(s->addr == _eextratext && strcmp((char*)s->sym + offset, "_eextratext")))
return 0;
}
/* Exclude symbols which vary between passes. */
if (strstr((char *)s->sym + offset, "_compiled."))
return 0;
for (i = 0; special_symbols[i]; i++)
if( strcmp((char *)s->sym + offset, special_symbols[i]) == 0 )
return 0;
return 1;
}
static void read_map(FILE *in)
{
while (!feof(in)) {
if (table_cnt >= table_size) {
table_size += 10000;
table = realloc(table, sizeof(*table) * table_size);
if (!table) {
fprintf(stderr, "out of memory\n");
exit (1);
}
}
if (read_symbol(in, &table[table_cnt]) == 0)
table_cnt++;
}
}
static void output_label(char *label)
{
if (symbol_prefix_char)
printf(".globl %c%s\n", symbol_prefix_char, label);
else
printf(".globl %s\n", label);
printf("\tALGN\n");
if (symbol_prefix_char)
printf("%c%s:\n", symbol_prefix_char, label);
else
printf("%s:\n", label);
}
/* uncompress a compressed symbol. When this function is called, the best table
* might still be compressed itself, so the function needs to be recursive */
static int expand_symbol(unsigned char *data, int len, char *result)
{
int c, rlen, total=0;
while (len) {
c = *data;
/* if the table holds a single char that is the same as the one
* we are looking for, then end the search */
if (best_table[c][0]==c && best_table_len[c]==1) {
*result++ = c;
total++;
} else {
/* if not, recurse and expand */
rlen = expand_symbol(best_table[c], best_table_len[c], result);
total += rlen;
result += rlen;
}
data++;
len--;
}
*result=0;
return total;
}
static void write_src(void)
{
unsigned int i, k, off;
unsigned int best_idx[256];
unsigned int *markers;
char buf[KSYM_NAME_LEN+1];
printf("#include <asm/types.h>\n");
printf("#if BITS_PER_LONG == 64\n");
printf("#define PTR .quad\n");
printf("#define ALGN .align 8\n");
printf("#else\n");
printf("#define PTR .long\n");
printf("#define ALGN .align 4\n");
printf("#endif\n");
printf(".data\n");
/* Provide proper symbols relocatability by their '_text'
* relativeness. The symbol names cannot be used to construct
* normal symbol references as the list of symbols contains
* symbols that are declared static and are private to their
* .o files. This prevents .tmp_kallsyms.o or any other
* object from referencing them.
*/
output_label("kallsyms_addresses");
for (i = 0; i < table_cnt; i++) {
if (toupper(table[i].sym[0]) != 'A') {
printf("\tPTR\t_text + %#llx\n",
table[i].addr - _text);
} else {
printf("\tPTR\t%#llx\n", table[i].addr);
}
}
printf("\n");
output_label("kallsyms_num_syms");
printf("\tPTR\t%d\n", table_cnt);
printf("\n");
/* table of offset markers, that give the offset in the compressed stream
* every 256 symbols */
markers = malloc(sizeof(unsigned int) * ((table_cnt + 255) / 256));
if (!markers) {
fprintf(stderr, "kallsyms failure: "
"unable to allocate required memory\n");
exit(EXIT_FAILURE);
}
output_label("kallsyms_names");
off = 0;
for (i = 0; i < table_cnt; i++) {
if ((i & 0xFF) == 0)
markers[i >> 8] = off;
printf("\t.byte 0x%02x", table[i].len);
for (k = 0; k < table[i].len; k++)
printf(", 0x%02x", table[i].sym[k]);
printf("\n");
off += table[i].len + 1;
}
printf("\n");
output_label("kallsyms_markers");
for (i = 0; i < ((table_cnt + 255) >> 8); i++)
printf("\tPTR\t%d\n", markers[i]);
printf("\n");
free(markers);
output_label("kallsyms_token_table");
off = 0;
for (i = 0; i < 256; i++) {
best_idx[i] = off;
expand_symbol(best_table[i], best_table_len[i], buf);
printf("\t.asciz\t\"%s\"\n", buf);
off += strlen(buf) + 1;
}
printf("\n");
output_label("kallsyms_token_index");
for (i = 0; i < 256; i++)
printf("\t.short\t%d\n", best_idx[i]);
printf("\n");
}
/* table lookup compression functions */
/* count all the possible tokens in a symbol */
static void learn_symbol(unsigned char *symbol, int len)
{
int i;
for (i = 0; i < len - 1; i++)
token_profit[ symbol[i] + (symbol[i + 1] << 8) ]++;
}
/* decrease the count for all the possible tokens in a symbol */
static void forget_symbol(unsigned char *symbol, int len)
{
int i;
for (i = 0; i < len - 1; i++)
token_profit[ symbol[i] + (symbol[i + 1] << 8) ]--;
}
/* remove all the invalid symbols from the table and do the initial token count */
static void build_initial_tok_table(void)
{
unsigned int i, pos;
pos = 0;
for (i = 0; i < table_cnt; i++) {
if ( symbol_valid(&table[i]) ) {
if (pos != i)
table[pos] = table[i];
learn_symbol(table[pos].sym, table[pos].len);
pos++;
}
}
table_cnt = pos;
}
/* replace a given token in all the valid symbols. Use the sampled symbols
* to update the counts */
static void compress_symbols(unsigned char *str, int idx)
{
unsigned int i, len, size;
unsigned char *p1, *p2;
for (i = 0; i < table_cnt; i++) {
len = table[i].len;
p1 = table[i].sym;
/* find the token on the symbol */
p2 = memmem(p1, len, str, 2);
if (!p2) continue;
/* decrease the counts for this symbol's tokens */
forget_symbol(table[i].sym, len);
size = len;
do {
*p2 = idx;
p2++;
size -= (p2 - p1);
memmove(p2, p2 + 1, size);
p1 = p2;
len--;
if (size < 2) break;
/* find the token on the symbol */
p2 = memmem(p1, size, str, 2);
} while (p2);
table[i].len = len;
/* increase the counts for this symbol's new tokens */
learn_symbol(table[i].sym, len);
}
}
/* search the token with the maximum profit */
static int find_best_token(void)
{
int i, best, bestprofit;
bestprofit=-10000;
best = 0;
for (i = 0; i < 0x10000; i++) {
if (token_profit[i] > bestprofit) {
best = i;
bestprofit = token_profit[i];
}
}
return best;
}
/* this is the core of the algorithm: calculate the "best" table */
static void optimize_result(void)
{
int i, best;
/* using the '\0' symbol last allows compress_symbols to use standard
* fast string functions */
for (i = 255; i >= 0; i--) {
/* if this table slot is empty (it is not used by an actual
* original char code */
if (!best_table_len[i]) {
/* find the token with the breates profit value */
best = find_best_token();
/* place it in the "best" table */
best_table_len[i] = 2;
best_table[i][0] = best & 0xFF;
best_table[i][1] = (best >> 8) & 0xFF;
/* replace this token in all the valid symbols */
compress_symbols(best_table[i], i);
}
}
}
/* start by placing the symbols that are actually used on the table */
static void insert_real_symbols_in_table(void)
{
unsigned int i, j, c;
memset(best_table, 0, sizeof(best_table));
memset(best_table_len, 0, sizeof(best_table_len));
for (i = 0; i < table_cnt; i++) {
for (j = 0; j < table[i].len; j++) {
c = table[i].sym[j];
best_table[c][0]=c;
best_table_len[c]=1;
}
}
}
static void optimize_token_table(void)
{
build_initial_tok_table();
insert_real_symbols_in_table();
/* When valid symbol is not registered, exit to error */
if (!table_cnt) {
fprintf(stderr, "No valid symbol.\n");
exit(1);
}
optimize_result();
}
int main(int argc, char **argv)
{
if (argc >= 2) {
int i;
for (i = 1; i < argc; i++) {
if(strcmp(argv[i], "--all-symbols") == 0)
all_symbols = 1;
else if (strncmp(argv[i], "--symbol-prefix=", 16) == 0) {
char *p = &argv[i][16];
/* skip quote */
if ((*p == '"' && *(p+2) == '"') || (*p == '\'' && *(p+2) == '\''))
p++;
symbol_prefix_char = *p;
} else
usage();
}
} else if (argc != 1)
usage();
read_map(stdin);
optimize_token_table();
write_src();
return 0;
}
Here is the error that I am getting:
File "joe.py", line 11
struct sym_entry {
^
SyntaxError: invalid syntax
Primary problem may be that the python code is actually C
Related
i am trying to use https://github.com/Spyros-DC/words-in-some-editdistance/blob/master/my_distance.cpp C++ implementation in python, however i kept receiving Segmentation fault (core dumped). Below is the entire code in python and C++, i have edited small parts of the original library to suit my use case. I have managed to find that when trying to use the unordered_map children.count(remaining_w.at(0)) it is throwing the segmentation fault error. I was wondering if anyone knows what is causing the error. Thank you so much in advance.
#include <iostream>
#include <unordered_map>
#include <string>
#include <fstream>
#include <unordered_set>
#include <vector>
#include <sstream>
#include <typeinfo>
using namespace std;
// using namespace std::chrono;
class trie{
public:
string word;
unordered_map<char, trie*> children;
// this function works
// with the argument flag set to zero
int insert(string w, int flag, string remaining_w = ""){
//the first time we call insert
if(flag == 0)
remaining_w = w;
int the_size = remaining_w.size();
if(children.count(remaining_w.at(0)) == 0){
children[remaining_w.at(0)] = new trie();
}
if(the_size == 0){
word = w;
return 0;
}else{
//the recursive calls with flag one
children[remaining_w.at(0)]->insert(w, 1, remaining_w.erase(0, 1));
return 0;
}
}
};
class AutoCorrect{
public:
// The tree
trie tree;
//the dictionary with the words
const int max_cost = 2;
const int too_big_distance = 10;
void insert(char* word){
ifstream ifp(word);
while(ifp >> word){
cout << word <<endl;
tree.insert(word, 0);
// }
}
}
void test(char* test){
cout << test << endl;
}
void search_recursive(trie* p_tree, char ch, const string& word, vector<int>& previous_row, int max_cost, unordered_map <string, int>& results)
{
int sz = previous_row.size();
int min_row = 12;
vector<int> current_row(sz, too_big_distance);
current_row[0] = previous_row[0] + 1;
// Calculate the min cost of insertion, deletion, match or substution
int insert_or_del, replace;
for (int i = 1; i < sz; i++) {
insert_or_del = min(current_row[i-1] + 1, previous_row[i] + 1);
replace = (word[i-1] == ch) ? previous_row[i-1] : (previous_row[i-1] + 1);
current_row[i] = min(insert_or_del, replace);
}
if ((current_row[sz-1] <= max_cost) && (p_tree->word != "")) {
results[p_tree->word] = current_row[sz-1];
}
for(auto& it: current_row){
if (it < min_row)
min_row = it;
}
if(min_row <= max_cost){
for(auto& it: p_tree->children){
search_recursive(it.second, it.first, word, current_row, max_cost, results);
}
}
}
int search(string word)
{
unordered_map <string, int> results;
int sz = word.size();
vector<int> current_row(sz + 1);
for (int i = 0; i <= sz; ++i){
current_row[i] = i;
}
for(auto& it: tree.children){
search_recursive(it.second, it.first, word, current_row, max_cost, results);
}
for(auto& p:results)
cout << p.first << ", " << p.second << endl;
return 0;
}
};
// The cost and a distance for vector initialization
extern "C" {
AutoCorrect* AutoCorrect_new(){ return new AutoCorrect(); }
void AutoCorrect_insert(AutoCorrect* autocorrect, char* word){ autocorrect->insert(word); }
void AutoCorrect_search(AutoCorrect* autocorrect, string input_word){ autocorrect->search(input_word); }
void AutoCorrect_test(AutoCorrect* autocorrect, char* name){ autocorrect-> test(name); }
}
Python main.py:
from ctypes import cdll
lib = cdll.LoadLibrary('autocorrect.so')
class AutoCorrect(object):
def __init__(self):
self.obj = lib.AutoCorrect_new()
def insert(self, word):
lib.AutoCorrect_insert(self.obj,word)
def search(self,input_word):
lib.AutoCorrect_search(self.obj,input_word)
def test(self,test):
lib.AutoCorrect_test(self.obj,test)
if __name__ == "__main__":
import json
WordCount = 0
autocorrect = AutoCorrect()
data_dir = "some_txt_file.txt"
autocorrect.insert(bytes(str(data_dir), encoding='utf8'))
Looking at the line you specified, i think there is an instance you are trying to add a value to a non existent key:
if(children.count(remaining_w.at(0)) == 0){
children[remaining_w.at(0)] = new trie();
if "children.count" returns 0 then that character is not present, then trying to add a value on the second line there means....
what i think you want to do on that line is:
if(children.count(remaining_w.at(0)) == 1){
children[remaining_w.at(0)] = new trie();
meaning you add the value only if key is present.
I have another question. I have been following a tutorial for creating a QPSK demodulator. Here is the link: https://wiki.gnuradio.org/index.php/Guided_Tutorial_GNU_Radio_in_C%2B%2B
I was able to fix a different issue and fixed a warning that I was receiving but, a new problem has come about and I can't seem to fix it. Here is the error:
Traceback (most recent call last):
File "/home/mariom/gr-tutorial/build/top_block.py", line 191, in <module>
main()
File "/home/mariom/gr-tutorial/build/top_block.py", line 167, in main
tb = top_block_cls()
File "/home/mariom/gr-tutorial/build/top_block.py", line 82, in __init__
self.tutorial_my_qpsk_demod_cb_0 = tutorial.my_qpsk_demod_cb(True)
AttributeError: module 'tutorial' has no attribute 'my_qpsk_demod_cb'
Noramlly when I see this error, I think I know how to fix this and go find the module tutorial and add the my_qpsk_demod_cb. This time, I seem to be running into the problem that I can't seem to find the right area or maybe I am in the right area. I understand that the issue is from the block I made from the tutorial so any thought? Here is block codes.
My_qpsk_demod_cb_impl.cc
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <gnuradio/io_signature.h>
#include "my_qpsk_demod_cb_impl.h"
namespace gr {
namespace tutorial {
my_qpsk_demod_cb::sptr
my_qpsk_demod_cb::make(bool gray_code)
{
return gnuradio::get_initial_sptr
(new my_qpsk_demod_cb_impl(gray_code));
}
/*
* The private constructor
*/
my_qpsk_demod_cb_impl::my_qpsk_demod_cb_impl(bool gray_code)
: gr::block("my_qpsk_demod_cb",
gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(1, 1, sizeof(char))),
d_gray_code(gray_code)
{
}
/*
* Our virtual destructor.
*/
my_qpsk_demod_cb_impl::~my_qpsk_demod_cb_impl()
{
}
void
my_qpsk_demod_cb_impl::forecast(int noutput_items,
gr_vector_int &ninput_items_required)
{
unsigned ninputs = ninput_items_required.size ();
for(unsigned i = 0; i < ninputs; i++)
ninput_items_required[i] = noutput_items;
}
unsigned char
my_qpsk_demod_cb_impl::get_minimum_distances(const gr_complex &sample)
{
if (d_gray_code) {
unsigned char bit0 = 0;
unsigned char bit1 = 0;
// The two left quadrants (quadrature component < 0) have this bit set to 1
if (sample.real() < 0) {
bit0 = 0x01;
}
// The two lower quadrants (in-phase component < 0) have this bit set to 1
if (sample.imag() < 0) {
bit1 = 0x01 << 1;
}
return bit0 | bit1;
} else {
// For non-gray code, we can't simply decide on signs, so we check every single
quadrant.
if (sample.imag() >= 0 and sample.real() >= 0) {
return 0x00;
}
else if (sample.imag() >= 0 and sample.real() < 0) {
return 0x01;
}
else if (sample.imag() < 0 and sample.real() < 0) {
return 0x02;
}
else if (sample.imag() < 0 and sample.real() >= 0) {
return 0x03;
}
}
return 0;
}
int
my_qpsk_demod_cb_impl::general_work (int noutput_items,
gr_vector_int &ninput_items,
gr_vector_const_void_star &input_items,
gr_vector_void_star &output_items)
{
const gr_complex *in = (const gr_complex *) input_items[0];
unsigned char *out = (unsigned char *) output_items[0];
gr_complex origin = gr_complex(0,0);
// Perform ML decoding over the input iq data to generate alphabets
for(int i = 0; i < noutput_items; i++)
{
// ML decoder, determine the minimum distance from all constellation points
out[i] = get_minimum_distances(in[i]);
}
// Tell runtime system how many input items we consumed on
// each input stream.
consume_each (noutput_items);
// Tell runtime system how many output items we produced.
return noutput_items;
}
} /* namespace tutorial */
} /* namespace gr */
my_qpsk_demod_cb_impl.h
#ifndef INCLUDED_TUTORIAL_MY_QPSK_DEMOD_CB_IMPL_H
#define INCLUDED_TUTORIAL_MY_QPSK_DEMOD_CB_IMPL_H
#include <tutorial/my_qpsk_demod_cb.h>
namespace gr {
namespace tutorial {
class my_qpsk_demod_cb_impl : public my_qpsk_demod_cb
{
private:
bool d_gray_code;
public:
my_qpsk_demod_cb_impl(bool gray_code);
~my_qpsk_demod_cb_impl();
unsigned char get_minimum_distances(const gr_complex &sample);
// Where all the action really happens
void forecast (int noutput_items, gr_vector_int &ninput_items_required);
int general_work(int noutput_items,
gr_vector_int &ninput_items,
gr_vector_const_void_star &input_items,
gr_vector_void_star &output_items);
};
} // namespace tutorial
} // namespace gr
#endif /* INCLUDED_TUTORIAL_MY_QPSK_DEMOD_CB_IMPL_H */
I think you are missing swig/dependencies or PYTHONPATH. I had the same issue, and was able to resolve it by following these fixes:
Install dependencies specific to your environment (including swig): https://wiki.gnuradio.org/index.php/UbuntuInstall#Bionic_Beaver_.2818.04.29_through_Eoan_Ermine_.2819.10.29
Configure PYTHONPATH and/or LD_LIBRARY_PATH according to these steps: https://wiki.gnuradio.org/index.php/ModuleNotFoundError
(Note that order may matter according to this case: https://lists.gnu.org/archive/html/discuss-gnuradio/2016-03/msg00065.html)
I'm trying to execute a C function using Python ctypes, but I'm doing something wrong.
The C function was originally converted from MATLAB to C code using MATLAB coder. The function gives as output an array of undefined length, which depends on the input.
This is the MATLAB code:
function a = array_output(n)
%$codegen
if n > 2*pi
a = 1:n;
else
a = [1,2,3];
end
end
And this is the obtained C code:
void array_output(double n, emxArray_real_T *a)
{
int i;
int loop_ub;
if (n > 6.2831853071795862) {
i = a->size[0] * a->size[1];
a->size[0] = 1;
loop_ub = (int)floor(n - 1.0);
a->size[1] = loop_ub + 1;
emxEnsureCapacity_real_T(a, i);
for (i = 0; i <= loop_ub; i++) {
a->data[i] = (double)i + 1.0;
}
} else {
i = a->size[0] * a->size[1];
a->size[0] = 1;
a->size[1] = 3;
emxEnsureCapacity_real_T(a, i);
a->data[0] = 1.0;
a->data[1] = 2.0;
a->data[2] = 3.0;
}
}
struct emxArray_real_T
{
double *data;
int *size;
int allocatedSize;
int numDimensions;
boolean_T canFreeData;
};
Please, find at the end of my question an example implementation they provide.
I am trying to execute it using Python's ctype using the following code:
dll = ctypes.cdll.LoadLibrary(dll_path)
class DataStruct(ctypes.Structure):
_fields_ = [
('data', ctypes.POINTER(ctypes.c_double)),
('size', ctypes.POINTER(ctypes.c_int)),
('allocatedSize', ctypes.c_int),
('numDimensions', ctypes.c_int),
('canFreeData', ctypes.c_bool)
]
array = ctypes.POINTER(ctypes.c_double)()
size = numpy.array([0, 0]).ctypes.data_as(ctypes.POINTER(ctypes.c_int))
allocatedSize = 0
numDimensions = 2
canFreeData = True
data_struct = DataStruct(array, size, allocatedSize, numDimensions, canFreeData)
dll.array_output.argtypes = [ctypes.c_double, DataStruct]
dll.array_output.restype = None
dll.array_output(50, data_struct)
The output data_struct contains the right size field (data_struct.size[1] is 50), but when I try to access data_struct.data[0], I get the following error:
ValueError: NULL pointer access
Can anyone help me understanding what I'm doing wrong here?
--
Example implementation (code snippets):
void main(){
// pseudo-code here
emxArray_real_T *a;
emxInitArray_real_T(&a, 2);
/* Initialize function 'array_output' input arguments. */
/* Call the entry-point 'array_output'. */
array_output(5.0, a);
}
void emxInitArray_real_T(emxArray_real_T **pEmxArray, int numDimensions)
{
emxInit_real_T(pEmxArray, numDimensions);
}
void emxInit_real_T(emxArray_real_T **pEmxArray, int numDimensions)
{
emxArray_real_T *emxArray;
int i;
*pEmxArray = (emxArray_real_T *)malloc(sizeof(emxArray_real_T));
emxArray = *pEmxArray;
emxArray->data = (double *)NULL;
emxArray->numDimensions = numDimensions;
emxArray->size = (int *)malloc(sizeof(int) * numDimensions);
emxArray->allocatedSize = 0;
emxArray->canFreeData = true;
for (i = 0; i < numDimensions; i++) {
emxArray->size[i] = 0;
}
}
void emxEnsureCapacity_real_T(emxArray_real_T *emxArray, int oldNumel)
{
int newNumel;
int i;
void *newData;
if (oldNumel < 0) {
oldNumel = 0;
}
newNumel = 1;
for (i = 0; i < emxArray->numDimensions; i++) {
newNumel *= emxArray->size[i];
}
if (newNumel > emxArray->allocatedSize) {
i = emxArray->allocatedSize;
if (i < 16) {
i = 16;
}
while (i < newNumel) {
if (i > 1073741823) {
i = MAX_int32_T;
} else {
i *= 2;
}
}
newData = calloc((unsigned int)i, sizeof(double));
if (emxArray->data != NULL) {
memcpy(newData, emxArray->data, sizeof(double) * oldNumel);
if (emxArray->canFreeData) {
free(emxArray->data);
}
}
emxArray->data = (double *)newData;
emxArray->allocatedSize = i;
emxArray->canFreeData = true;
}
}
The second argument of array_output is a emxArray_real_T *, but you're trying to pass the structure by value as if it were just a emxArray_real_T. To fix that, change dll.array_output.argtypes = [ctypes.c_double, DataStruct] to dll.array_output.argtypes = [ctypes.c_double, ctypes.POINTER(DataStruct)] and dll.array_output(50, data_struct) to dll.array_output(50, ctypes.byref(data_struct)).
Recently I've been doing some challenges on HackerRank and came across this one. First, I tried with Python, and then C. Both of my codes failed due to timeout restrictions.
It would be very helpful, if someone can tell me what can be improved in (one of) my codes (performance-wise).
Thank you.
Challenge description:
C code:
int minBox(int *box, int l, int r){
int min=box[l];
for(int i = l+1; i<=r; i++)
if(box[i] < min)
min = box[i];
return min;
}
int sumBox(int *box, int l, int r){
int sum=0;
for(int i = l; i<=r; i++)
sum += box[i];
return sum;
}
void operateOnBox(int *op, int *box){
switch(op[0]){
case 3:
printf("%d\n", minBox(box, op[1], op[2]));
break;
case 4:
printf("%d\n", sumBox(box, op[1], op[2]));
break;
case 1:
for(int i = op[1]; i <= op[2]; i++)
box[i] += op[3];
break;
case 2:
for(int i = op[1]; i <= op[2]; i++)
box[i] = (int) floor(box[i]/((float)op[3]));
break;
}
}
int main()
{
int n, q, *box;
scanf("%d %d", &n, &q);
box = (int*) malloc(sizeof(int) * n);
for(int i = 0; i<n; i++)
scanf("%d", box+i);
for(int i = 0; i<q; i++){
int op[4];
scanf("%d %d %d", op, op+1, op+2);
if(op[0] == 1 || op[0] == 2)
scanf("%d", op+3);
operateOnBox(op, box);
}
return 0;
}
Python 3 code:
def operate(op, box):
if op[0] == 3:
print(min(box[op[1]:op[2]+1]))
elif op[0] == 4:
print(sum(box[op[1]:op[2]+1]))
elif op[0] == 1:
box[op[1]:op[2]+1] = map(lambda x: x+op[3], box[op[1]:op[2]+1])
elif op[0] == 2:
box[op[1]:op[2]+1] = map(lambda x: math.floor(x/op[3]), box[op[1]:op[2]+1])
if __name__ == '__main__':
nq = input().split()
n = int(nq[0])
q = int(nq[1])
box = list(map(int, input().rstrip().split()))
for i in range(q):
op = list(map(int, input().split()))
operate(op, box)
using scanf() and printf() is very slow. Suggest the following two functions;
void fastRead( size_t *a );
void fastWrite( size_t a );
inline void fastRead(size_t *a)
{
int c=0;
// note: 32 is space character
while (c<33) c=getchar_unlocked();
// initialize result value
*a=0;
// punctuation parens, etc are show stoppers
while (c>47 && c<58)
{
*a = (*a)*10 + (size_t)(c-48);
c=getchar_unlocked();
}
//printf( "%s, value: %lu\n", __func__, *a );
} // end function: fastRead
inline void fastWrite(size_t a)
{
char snum[20];
//printf( "%s, %lu\n", __func__, a );
int i=0;
do
{
// 48 is numeric character 0
snum[i++] = (char)((a%10)+(size_t)48);
a=a/10;
}while(a>0);
i=i-1; // correction for overincrement from prior 'while' loop
while(i>=0)
{
putchar_unlocked(snum[i--]);
}
putchar_unlocked('\n');
} // end function: fastWrite
I need to merge the client and server code. I would appreciate your help in this regard. I share C server and client code in the combo Python. Error grapefruit are available in the bottom line.
C Server Code
#include <unistd.h>
#include <stdio.h> // standard input / output functions
#include <stdlib.h>
#include <string.h> // string function definitions
#include <fcntl.h> // File control definitions
#include <errno.h> // Error number definitions
#include <termios.h> // POSIX terminal control definitions
#include <time.h>
#include <stdint.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include "list.h"
#include "pack.h"
#define SOCK_PATH "../sockets/socketNodeServer"
#define DEBUG_FILE "./debug.txt"
#pragma pack(1)
// Structure definitions
typedef struct serialRx_s{
list* llistScatteredRx;
list* llistOrderedRx;
uint8_t scratchpad[SCRATCHPAD_SIZE];
uint8_t remaining;
uint16_t lostPackets;
uint16_t receivedPackets;
int fd;
}serialRx_t;
typedef struct serialTx_s{
list* llistTx;
uint16_t sentPackets;
int fd;
}serialTx_t;
typedef struct monitor_s{
struct serialRx_s *rx_p;
struct serialTx_s *tx_p;
FILE *fp;
}monitor_t;
#pragma pack()
// Public function prototypes
// Private function prototypes
static void *rxSerial_f(void *arg);
static void *txSerial_f(void *arg);
static void *log_f(void *arg);
static void *monitor_f(void *arg);
static int orderScattered_rxData(struct serialRx_s *rx);
static int fillupScratchpad(struct serialRx_s *rx);
static void freeNode(void *data);
static void *prep_TxGoodies(int fd);
static void *prep_RxGoodies(int fd);
static void *prep_monitoring(struct serialRx_s *rx, struct serialTx_s *tx);
static void set_blocking (int fd, int should_block);
static int set_interface_attribs (int fd, int speed, int parity);
static void *form_node_data_packet(void *buf, int len);
static int setNonBlocking(int fd);
static int set_interface_attribs (int fd, int speed, int parity)
{
struct termios tty;
memset (&tty, 0, sizeof tty);
if (tcgetattr (fd, &tty) != 0)
{
printf ("error %d from tcgetattr", errno);
return -1;
}
cfsetospeed (&tty, speed);
cfsetispeed (&tty, speed);
tty.c_cflag = (tty.c_cflag & ~CSIZE) | CS8; // 8-bit chars
// disable IGNBRK for mismatched speed tests; otherwise receive break
// as \000 chars
tty.c_iflag &= ~IGNBRK; // disable break processing
tty.c_lflag = 0; // no signaling chars, no echo,
// no canonical processing
tty.c_oflag = 0; // no remapping, no delays
// For details about blocking in non canonical (binary mode)
// check out http://www.tldp.org/HOWTO/html_single/Serial-HOWTO/
tty.c_cc[VMIN] = 0; // read doesn't block
tty.c_cc[VTIME] = 5; // 0.5 seconds read timeout
tty.c_iflag &= ~(IXON | IXOFF | IXANY); // shut off xon/xoff ctrl
tty.c_cflag |= (CLOCAL | CREAD);// ignore modem controls,
// enable reading
tty.c_cflag &= ~(PARENB | PARODD); // shut off parity
tty.c_cflag |= parity;
tty.c_cflag &= ~CSTOPB;
tty.c_cflag &= ~CRTSCTS;
if (tcsetattr (fd, TCSANOW, &tty) != 0)
{
printf ("error %d from tcsetattr", errno);
return -1;
}
return 0;
}
static void set_blocking (int fd, int should_block)
{
struct termios tty;
memset (&tty, 0, sizeof tty);
if (tcgetattr (fd, &tty) != 0)
{
printf ("error %d from tggetattr", errno);
return;
}
tty.c_cc[VMIN] = should_block ? 1 : 0;
tty.c_cc[VTIME] = 5; // 0.5 seconds read timeout
if (tcsetattr (fd, TCSANOW, &tty) != 0)
printf ("error %d setting term attributes", errno);
}
static void * prep_monitoring(struct serialRx_s *rx, struct serialTx_s *tx)
{
struct monitor_s *monitor_p = NULL;
monitor_p = (struct monitor_s *)malloc(sizeof(struct monitor_s));
if(NULL == monitor_p){
return NULL;
}
monitor_p->rx_p = rx;
monitor_p->tx_p = tx;
monitor_p->fp = fopen(DEBUG_FILE, "w+");
return monitor_p;
}
static void *prep_RxGoodies(int fd)
{
struct serialRx_s *rx = NULL;
rx = (struct serialRx_s *)malloc(sizeof(struct serialRx_s));
rx->llistScatteredRx = create_list();
rx->llistOrderedRx = create_list();
rx->fd = fd;
memset(rx->scratchpad, 0, sizeof(rx->scratchpad));
rx->remaining = 0;
rx->lostPackets = 0;
rx->receivedPackets = 0;
return rx;
}
static void *prep_TxGoodies(int fd)
{
struct serialTx_s *tx = NULL;
tx = (struct serialTx_s *)malloc(sizeof(struct serialTx_s));
tx->llistTx = create_list();
tx->fd = fd;
tx->sentPackets = 0;
return tx;
}
static void freeNode(void *data)
{
free( (uint8_t *)data);
}
static int fillupScratchpad(struct serialRx_s *rx)
{
int targetNodeIndex = -1;
int nodeLen = 0;
uint8_t *nodeData = NULL;
int offset = 0;
uint8_t *pointer = NULL;
targetNodeIndex = payloadLen_2_index(rx->llistScatteredRx, PACKET_SIZE - rx->remaining);
//printf("targetNodeIndex value %d\n", targetNodeIndex);
for(int i=0; i <= targetNodeIndex ; i++){
offset = rx->remaining;
pointer = (uint8_t *)front(rx->llistScatteredRx); // first byte is for length
nodeLen = pointer[0];
//nodeLen = ((uint8_t *)front(rx->llistScatteredRx))[0]; // first byte is for length
//printf("nodeLen in fillupScratchpad %d\n", nodeLen);
nodeData = (uint8_t *)front(rx->llistScatteredRx) + 1; // first byte is for length
memcpy(rx->scratchpad + offset, nodeData, nodeLen);
rx->remaining += nodeLen;
//for(int j=0; j<rx->remaining; j++)
//{
// printf("scratchpad[%d]: %X\n", j, (rx->scratchpad)[j]);
//}
remove_front(rx->llistScatteredRx, freeNode);
}
return targetNodeIndex;
}
static int orderScattered_rxData(struct serialRx_s *rx)
{
int packetBeginIndex = 0;
struct raw_node_data_s *raw = NULL;
// parse the scratchpad buffer until the last remaining byte
// note that since we have a larger buffer size than what we use
// it's safe to do this.
for(int i=0; i < (rx->remaining) ; i++)
{
// Check whether we have a suitable package
if(rx->scratchpad[i] == START_CODE &&
rx->scratchpad[i+PACKET_SIZE-1] == STOP_CODE)
{
//printf("start & stop matches\n");
raw = (struct raw_node_data_s *)malloc(sizeof(struct raw_node_data_s));
memcpy(raw, rx->scratchpad + i, sizeof(struct raw_node_data_s));
//print_raw_node_data(raw);
push_back(rx->llistOrderedRx, raw);
rx->receivedPackets++;
//TODO: Check for CRC
// clear up memory area between beginning of scratchpad and Stop_Code
memset(rx->scratchpad, 0, i+PACKET_SIZE-1);
// move remaining bytes to the beginning of scratchpad buffer
// no overlapping should occur but still, use memmove instead of memcpy
memmove(rx->scratchpad,
rx->scratchpad + i + PACKET_SIZE, // point to right after the healthy packet
rx->remaining - ( i + PACKET_SIZE)); // get remaining bytes after packet end
// update remaining bytes value
rx->remaining = rx->remaining - (i + PACKET_SIZE);
packetBeginIndex = i; // success
break;
}
}
// if no packets can be formed, check whether we are running out of
// scratchpad buffer, clear up memory if this is the case. Make sure
// to increase packet lost counter
//if( !packetBeginIndex && (rx->remaining >= 2 * PACKET_SIZE) )
if( (rx->remaining >= (3 * PACKET_SIZE)) )
{
printf("we are running out of space\n");
printf("scratchpad size: %d\n", rx->remaining);
for(int i=0; i < (rx->remaining) ; i++)
{
if(rx->scratchpad[i] == START_CODE){
// clear up the first packet area and move up the
// remaining bytes to the beginning of buffer
memset(rx->scratchpad, 0, i-1);
memmove(rx->scratchpad,
rx->scratchpad + i,
rx->remaining - i );
rx->remaining -= i;
rx->lostPackets += 1;
}
}
}
// don't care for START_CODE, clear up an area
// big enough to hold a full packet
if((rx->remaining >= 3 * PACKET_SIZE)){
printf("buffer is a complete mess, clear up stuff\n");
// buffer is a complete mess,
// clear up a whole packet
memset(rx->scratchpad, 0, PACKET_SIZE);
memmove(rx->scratchpad,
rx->scratchpad + PACKET_SIZE+1,
rx->remaining - PACKET_SIZE);
rx->remaining -= PACKET_SIZE;
rx->lostPackets += 1;
}
//for(int j=0; j<rx->remaining; j++)
//{
// printf("scratchpad after cleanup[%d]: %X\n", j, (rx->scratchpad)[j]);
//}
return packetBeginIndex;
}
static void *txSerial_f(void *arg)
{
struct serialTx_s *tx = (struct serialTx_s *)arg;
struct raw_node_data_s *txRaw = NULL;
int n = 0;
//txRaw = prep_transaction_data();
//print_raw_node_data(txRaw);
sleep(1);
while(1)
{
//n = write(tx->fd, txRaw, sizeof(txRaw));
if(size(tx->llistTx)){
txRaw = front(tx->llistTx);
n = write(tx->fd, txRaw, PACKET_SIZE);
//printf("sending %d bytes via serial \n", n);
remove_front(tx->llistTx, freeNode);
tx->sentPackets += 1;
}
sleep(1);
}
return NULL;
}
static void *form_node_data_packet(void *buf, int len)
{
struct raw_node_data_s *raw = NULL;
raw = (struct raw_node_data_s *)malloc(sizeof(struct raw_node_data_s));
if(!raw){
fprintf(stderr,"can't allocate memory for raw node\n");
return NULL;
}
memcpy(raw, buf, len);
//print_raw_node_data(raw);
return raw;
}
//TODO: Move this function to a new source file for socket operations
static int setNonBlocking(int fd)
{
int flags;
/* if O_NONBLOCK is defined, use the fcntl function */
if(-1 == (flags = fcntl(fd, F_GETFL, 0))){
flags = 0;
}
return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}
static void *monitor_f(void *arg)
{
struct monitor_s *mon = (struct monitor_s *)arg;
struct raw_node_data_s *txRaw = NULL;
uint8_t rxbuf[100];
// socket operation related variables
int fdBind, fdAccept;
int t, len, status;
struct sockaddr_un local;
struct sockaddr_un remote;
if(-1 == (fdBind = socket(AF_UNIX, SOCK_STREAM, 0)))
{
fprintf(stderr, "can't open socket: %s\n", strerror(errno));
return (void *)NULL;
}
local.sun_family = AF_UNIX;
strcpy(local.sun_path, SOCK_PATH);
unlink(local.sun_path);
len = strlen(local.sun_path) + sizeof(local.sun_family);
if( bind(fdBind, (struct sockaddr *)&local, len) == -1){
fprintf(stderr, "can't bind: %s\n", strerror(errno));
return (void *)NULL;
}
if(-1 == listen(fdBind, 5)){ // number of listenes can actually be less
fprintf(stderr, "can't listen: %s\n", strerror(errno));
return (void *)NULL;
}
for(;;){
socklen_t size = sizeof(remote);
int rcvdBytes = 0;
fprintf(stderr, "waiting for a connection\n");
if( -1 == (fdAccept = accept(fdBind, (struct sockaddr *)&remote, &size)) )
{
fprintf(stderr, "can't accept: %s\n", strerror(errno));
return (void *)NULL;
}
//setNonBlocking(fdAccept);
status = 1;
printf("connected\n");
do{
if( (t = recv(fdAccept, rxbuf, 100, 0)) > 0){
fprintf(stderr, "incoming bytes len from server: %d\n", t);
for(int ii=0; ii < t; ii++){
printf("incoming data[%i]:%X\n", ii, rxbuf[ii]);
}
txRaw = (struct raw_node_data_s *)form_node_data_packet(rxbuf, t);
push_back(mon->tx_p->llistTx, txRaw);
}else if(t < 0){
perror("recv"); // if nonblocking then wouldhaveblocked would come here too
}else{
fprintf(stderr, "server closed connection\n");
status = 0;
}
usleep(200);
}while(status);
sleep(2);
close(fdBind);
} // while(1), thread start
return NULL;
}
static void *log_f(void *arg)
{
struct monitor_s *log = (struct monitor_s *)arg;
struct raw_node_data_s *rxRaw = NULL;
while(1)
{
if( size(log->rx_p->llistOrderedRx)){
rxRaw = front(log->rx_p->llistOrderedRx);
printf("log thread\n");
print_raw_node_data(rxRaw);
remove_front(log->rx_p->llistOrderedRx, freeNode);
//fprintf(mon->fp, "\rSent Packets: %d", i);
fprintf(log->fp, "Sent Packets: %d\n", log->tx_p->sentPackets);
fprintf(log->fp, "Received Packets: %d\n", log->rx_p->receivedPackets);
fprintf(log->fp, "Dropped Packets: %d\n", log->rx_p->lostPackets);
fflush(log->fp);
sleep(1);
}
} // while (1)
return NULL;
}
static void *rxSerial_f(void *arg)
{
struct serialRx_s *rx = (struct serialRx_s *)arg;
int n = 0;
uint8_t buf[100] = {0};
uint8_t *dataPack = NULL;
tcflush(rx->fd, TCIFLUSH); /* Discards old data in the rx buffer */
while(1)
{
n = read(rx->fd, (uint8_t *)buf, sizeof(struct raw_node_data_s));
//for(int ii=0; ii < n; ii++){
// printf("incoming serial data[%i]:%X\n", ii, ((uint8_t *)buf)[ii]);
//}
if(n > 0){
//printf("read %d bytes\n", n);
dataPack = (uint8_t *)malloc(sizeof(uint8_t)* n);
dataPack[0] = n;
memcpy(dataPack + 1, buf, sizeof(uint8_t)*n);
push_back(rx->llistScatteredRx, dataPack);
//printf("linked list size after read: %d\n", size(rx->llistScatteredRx));
//for(int i=0; i<n; i++)
//{
// printf("read data[%d]: %X\n", i, dataPack[i+1]);
//}
dataPack = NULL;
memset(buf, 0, sizeof(buf)); // clear up
// Check whether we have enough data in the
// scratchpad to forma packet
fillupScratchpad(rx);
orderScattered_rxData(rx);
}else if(n < 0){
printf("error in read operation\n");
}else{
//printf("no data - rx\n");
}
sleep(1);
} // while(1)
return NULL;
} //void *rxSerial_f(void *arg)
// *************************************************
// *************************************************
// *************************************************
// ************** TODO *************************
// * Have thread functions in seperate files
// * Implement CRC check mechanism
// * Implement DAC switch mechanism
// * Implement for loop on writes to Serial Device
// to make sure that all data is sent on the tx line
int main(void)
{
pthread_t idThreadSerial[2]; // wr, rd
char *portname = "/dev/ttyS2";
struct serialRx_s *serialRx_p = NULL;
struct serialTx_s *serialTx_p = NULL;
struct monitor_s *monitor_p = NULL;
srand(time(NULL)); // generate seed data for random()
printf("size of raw_node_data_s structure: %ld\n", sizeof(struct raw_node_data_s));
int fd = open (portname, O_RDWR | O_NOCTTY | O_SYNC);
set_interface_attribs (fd, B38400, 0); // set speed to 38400 bps, 8n1 (no parity)
//set_blocking (fd, 0); // set no blocking
serialTx_p = (struct serialTx_s *)prep_TxGoodies(fd);
serialRx_p = (struct serialRx_s *)prep_RxGoodies(fd);
monitor_p = (struct monitor_s *)prep_monitoring(serialRx_p, serialTx_p);
fwrite ("hello!\n", sizeof(uint8_t), 7, stdout);
sleep(1);
pthread_create(&idThreadSerial[3], NULL, log_f, (void *)monitor_p);
pthread_create(&idThreadSerial[2], NULL, monitor_f, (void *)monitor_p);
//pthread_create(&idThreadSerial[1], NULL, rxSerial_f, (void *)serialRx_p);
//pthread_create(&idThreadSerial[0], NULL, txSerial_f, (void *)serialTx_p);
pthread_join(idThreadSerial[0], NULL);
pthread_join(idThreadSerial[1], NULL);
pthread_join(idThreadSerial[2], NULL);
pthread_join(idThreadSerial[3], NULL);
fwrite("all threads returned, exiting now...\n", sizeof(uint8_t), 40, stdout);
return 0;
}
Python Client Code
# -*- coding: utf-8 -*-
import socket
import os, os.path
print "Connecting..."
if os.path.exists( "../sockets/socketNodeServer" ):
client = socket.socket( socket.AF_UNIX, socket.SOCK_DGRAM )
client.connect( "../sockets/socketNodeServer" )
print "Ready."
print "Ctrl-C to quit."
print "Sending 'DONE' shuts down the server and quits."
while True:
try:
x = raw_input( "> " )
if "" != x:
print "SEND:", x
client.send( x )
if "DONE" == x:
print "Shutting down."
break
except KeyboardInterrupt, k:
print "Shutting down."
client.close()
else:
print "Couldn't Connect!"
print "Done
"
Error
Connecting...
Traceback (most recent call last):
File "client.py", line 8, in <module>
client.connect( "../sockets/socketNodeServer" )
File "/usr/lib/python2.7/socket.py", line 224, in meth
return getattr(self._sock,name)(*args)
socket.error: [Errno 91] Protocol wrong type for socket
In your C-Code you create a stream
fdBind = socket(AF_UNIX, SOCK_STREAM, 0)
and in Python a datagram:
client = socket.socket( socket.AF_UNIX, socket.SOCK_DGRAM )
Sure, this is a wrong type for socket. Use the same STREAM or DGRAM on both sides.